public DefaultProviderSwitcher(
            MembershipProviderAccessor membershipProviderAccessor, 
            RoleProviderAccessor roleProviderAccessor, 
            MembershipProvider provider, 
            RoleProvider roleProvider)
        {
            Condition.Requires(membershipProviderAccessor, "membershipProviderAccessor").IsNotNull();
            Condition.Requires(roleProviderAccessor, "roleProviderAccessor").IsNotNull();
            Condition.Requires(provider, "provider").IsNotNull();
            Condition.Requires(roleProvider, "roleProvider").IsNotNull();

            this.membershipProviderAccessor = membershipProviderAccessor;
            this.roleProviderAccessor = roleProviderAccessor;

            this.originalMembershipInitializedDefault =
                membershipProviderAccessor.SetInitializedDefaultProviderAndReturnOriginalValue(true);
            this.originalMembershipInitialized = membershipProviderAccessor.SetInitializedAndReturnOriginalValue(true);
            this.originalMembershipProvider = membershipProviderAccessor.SetProviderAndReturnOriginalValue(provider);

            this.originalRoleEnabledInitialized = roleProviderAccessor.SetEnabledAndReturnOriginalValue(true);
            this.originalRoleProviders =
                roleProviderAccessor.SetProvidersAndReturnOriginalValue(new RoleProviderCollection());
            this.originalRoleInitializedDefault =
                roleProviderAccessor.SetInitializedDefaultProviderAndReturnOriginalValue(true);
            this.originalRoleInitialized = roleProviderAccessor.SetInitializedAndReturnOriginalValue(true);
            this.originalRoleProvider = roleProviderAccessor.SetProviderAndReturnOriginalValue(roleProvider);
        }

 public MembershipService()
 {
     if (Membership.Provider is MonsterMembershipProvider)
         Provider = Membership.Provider;
     else
         throw new InvalidOperationException("Membership provider not supported");
 }

        public void InitializeMembershipProviderFromConfigEntry(MembershipProvider result,
            IEnumerable<KeyValuePair<string, string>> simulatedAppConfigSettings)
        {
            NameValueCollection nameValueCollection = null;

            MembershipSection membership = ConfigurationManager.GetSection("system.web/membership") as MembershipSection;

            foreach (ProviderSettings settings in membership.Providers)
            {
                if (settings.Name == FixtureConstants.NameOfConfiguredMembershipProvider)
                {
                    nameValueCollection = new NameValueCollection(settings.Parameters);
                    break;
                }
            }

            if (nameValueCollection == null)
            {
                throw new Exception("Configuration not found for membership provider RavenDBMembership.");
            }

            nameValueCollection["connectionStringName"] = "StubConnectionString";

            foreach (var kvp in simulatedAppConfigSettings)
            {
                ValidateConfigurationValue(kvp.Key, kvp.Value);
                nameValueCollection.Set(kvp.Key, kvp.Value);
            }

            result.Initialize(FixtureConstants.NameOfConfiguredMembershipProvider, nameValueCollection);
        }

        public AuthenticationService(MembershipProvider membershipProvider)
        {
            _membershipProvider = membershipProvider
                                  ?? Membership.Provider;

            MinPasswordLength = _membershipProvider.MinRequiredPasswordLength;
        }

        public AccountMembershipService(MembershipProvider provider)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            _provider = provider;
        }

 private static SimpleMembershipProvider CreateDefaultSimpleMembershipProvider(string name, MembershipProvider currentDefault)
 {
     MembershipProvider previousProvider = currentDefault;
     SimpleMembershipProvider provider = new SimpleMembershipProvider(previousProvider);
     NameValueCollection config = new NameValueCollection();
     provider.Initialize(name, config);
     return provider;
 }

 public SQLiteFacebookMembershipProvider(string connectionString, string tableName, MembershipProvider membershipProvider)
 {
     _connectionString = connectionString;
     _tableName = tableName ?? "facebook_users";
     _membershipProvider = membershipProvider;
     // we cound had done _membershipProvider = membershipProvider ?? Membership.Provider
     // but that wouldn't allow to work under client profile
 }

 public WebValidateUserPolicy(MembershipProvider provider)
     : base((IMemberShipProvider)provider)
 {
     this.MaxInvalidPasswordAttempts = provider.MaxInvalidPasswordAttempts;
     this.PasswordAttemptWindow = provider.PasswordAttemptWindow;
     this.PasswordStrengthRegularExpression = provider.PasswordStrengthRegularExpression;
     this.MinRequiredPasswordLength = provider.MinRequiredPasswordLength;
 }

 public static UserNamePasswordValidator CreateMembershipProviderValidator(MembershipProvider provider)
 {
     if (provider == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("provider");
     }
     return new MembershipProviderValidator(provider);
 }

 public MySqlSimpleMembershipProvider(MembershipProvider previousProvider)
 {
   _prevProvider = previousProvider;
   if (_prevProvider != null)
   {
     _prevProvider.ValidatingPassword += delegate(object sender, ValidatePasswordEventArgs args) { this.OnValidatingPassword(args); };
   }
 }

		public ClientFormsIdentity (string name, string password, MembershipProvider provider, string authenticationType, bool isAuthenticated, CookieContainer authenticationCookies)
		{
			Password = password;
			Name = name;
			Provider = provider;
			AuthenticationType = authenticationType;
			IsAuthenticated = isAuthenticated;
			AuthenticationCookies = authenticationCookies;
		}

 public ClientFormsIdentity(string name, string password, MembershipProvider provider, string authenticationType, bool isAuthenticated, CookieContainer authenticationCookies)
 {
     _Name = name;
     _AuthenticationType = authenticationType;
     _IsAuthenticated = isAuthenticated;
     _AuthenticationCookies = authenticationCookies;
     _Password = GetSecureStringFromString(password);
     _Provider = provider;
 }

    public FakeMembershipProviderTest()
    {
      this.localProvider = Substitute.For<MembershipProvider>();
      this.provider = new FakeMembershipProvider();
      this.provider.LocalProvider.Value = this.localProvider;

      this.user = new MembershipUser("fake", UserName, new Guid(), null, null, null, true, false, DateTime.MinValue,
        DateTime.Now, DateTime.Now, DateTime.MinValue, DateTime.MinValue);
    }

 public static RequestInterceptor Create(string realm, MembershipProvider membershipProvider)
 {
     var basicAuthenticationCredentialsExtractor = new BasicAuthenticationCredentialsExtractor(new Base64Decoder(), new DecodedCredentialsExtractor());
      var httpRequestAuthorizationExtractor = new AuthorizationStringExtractor();
      var responseMessageFactory = new ResponseMessageFactory(realm);
      var serviceSecurityContextFactory = new ServiceSecurityContextFactory(new AuthorizationPolicyFactory());
      var basicAuthenticationManager = new BasicAuthenticationManager(basicAuthenticationCredentialsExtractor, httpRequestAuthorizationExtractor, membershipProvider, responseMessageFactory, serviceSecurityContextFactory);
      return new BasicAuthenticationInterceptor(basicAuthenticationManager);
 }

        public override void PostInitializeUpdate(MembershipProvider provider)
        {
            var connectionStringProperty = typeof(SqlMembershipProvider).GetField("_sqlConnectionString",
                                                                                   BindingFlags.NonPublic |
                                                                                   BindingFlags.Instance);

            Assert.That(connectionStringProperty, Is.Not.Null);

            connectionStringProperty.SetValue(provider, DatabaseInitialization.GetConnectionStringFor(FixtureConstants.DatabaseName));
        }

 public SimpleMembershipProvider(MembershipProvider previousProvider) {
     _previousProvider = previousProvider;
     if (_previousProvider != null) {
         _previousProvider.ValidatingPassword += (sender, args) => {
             if (!InitializeCalled) {
                 OnValidatingPassword(args);
             }
         };
     }
 }

 internal BasicAuthenticationManager(BasicAuthenticationCredentialsExtractor basicAuthenticationCredentialsExtractor,
  AuthorizationStringExtractor httpRequestAuthorizationExtractor, 
  MembershipProvider membershipProvider, 
  ResponseMessageFactory responseMessageFactory, 
  ServiceSecurityContextFactory serviceSecurityContextFactory)
 {
     this.basicAuthenticationCredentialsExtractor = basicAuthenticationCredentialsExtractor;
      this.httpRequestAuthorizationExtractor = httpRequestAuthorizationExtractor;
      this.membershipProvider = membershipProvider;
      this.responseMessageFactory = responseMessageFactory;
      this.serviceSecurityContextFactory = serviceSecurityContextFactory;
 }

    public void RestorePasswordShouldReturnsNewPassword(FakeMembershipUser user, MembershipProvider membershipProvider, AccountRepository repo)
    {
      user.ProviderName.Returns("fake");
      membershipProvider.ResetPassword(Arg.Any<string>(), Arg.Any<string>()).Returns("new password");
      membershipProvider.Name.Returns("fake");
      membershipProvider.GetUser(Arg.Any<string>(), Arg.Any<bool>()).Returns(user);

      using (new MembershipSwitcher(membershipProvider))
      {
        repo.RestorePassword(@"extranet\John").Should().Be("new password");
      }
    }

        public ProviderInitializationHttpModule(MembershipProvider membershipProvider, RoleProvider roleProvider)
        {
            MembershipCreateStatus createStatus;

            Roles.CreateRole("Administrator");

            string username = ConfigurationManager.AppSettings["default:username"];
            string password = ConfigurationManager.AppSettings["default:password"];
            string email = ConfigurationManager.AppSettings["default:email"];

            Membership.CreateUser(username, password, email, null, null, true, null, out createStatus);
            Roles.AddUserToRole("admin", "Administrator");
        }

        public override void PostInitializeUpdate(MembershipProvider provider)
        {
            var connectionStringProperty = GetConnectionStringProperty();

            var connectionStringSettings = new ConnectionStringSettings()
            {
                ProviderName = "System.Data.SqlClient",
                ConnectionString = "MultipleActiveResultSets=True;" + DatabaseInitialization.GetConnectionStringFor(FixtureConstants.UniversalMembershipProviderDatabaseName)
            };

            connectionStringProperty.SetValue(provider, connectionStringSettings, null);

            base.PostInitializeUpdate(provider);
        }