protected AppendEntryBaseTest()
        {
            // Arrange  
            var mocker = new AutoMocker();

            ServerIdentifier = new ServerIdentifier();

            mocker.Use(ServerIdentifier);

            mocker.Setup<ISubject<AppendEntryMessage>>(p => p.Subscribe(It.IsAny<IObserver<AppendEntryMessage>>()))
                .Callback<IObserver<AppendEntryMessage>>((o) =>
                {
                    AppendEntryCallback = o;
                });
            AppendEntryCallback = mocker.Get<ISubject<AppendEntryMessage>>();

            AppendEntryResult = new Subject<AppendEntryResultMessage>();
            Election = new Election();
            LogReplication = new LogReplication();
            
            AppendEntry = new Rafting.AppendEntry(AppendEntryResult,
                mocker.Get<ISubject<AppendEntryMessage>>(),
                mocker.Get<IHartbeatTimer>(),
                LogReplication,
                Election,
                mocker.Get<ILoggerFactory>(),
                new RaftOptions(),
                mocker.Get<ServerIdentifier>(),
                null);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="FantasyTeamPresenter"/> class.
 /// </summary>
 /// <param name="view">The view.</param>
 /// <param name="owningPerson">The owning person.</param>
 /// <param name="subject">The subject.</param>
 public FantasyTeamPresenter(IFantasyTeamView view, string owningPerson, ISubject subject)
 {
     _View = view;
     _View.Unsubscribing += Unsubscribing;
     FantasyTeam = owningPerson;
     _Subject = subject;
 }

 public void RemoveSubject(ISubject s)
 {
     if (IsSubjectListened(s))
     {
         subjectList.Remove(s);
     }
 }

 public void AddSubject(ISubject s)
 {
     if (!IsSubjectListened(s))
     {
         subjectList.Add(s);
     }
 }

 public FriendObserver(ListBox displayBox, ISubject friendSubject)
 {
     status = "";
     this.friendSubject = friendSubject;
     this.displayBox = displayBox;
     friendSubject.addObserver(this);
 }

        public RulerBase(IModifierBus bus, IRules rules, ISubject<IInfo> infoChannel)
        {
            _bus = bus;
            _rules = rules;

            _infoChannel = infoChannel;
        }

 public PriceGrabber(ISubject subject, double usaPrice, double israelPrice)
 {
     _subject = subject;
     _subject.Register(this);
     USAPrice = usaPrice;
     IsraelPrice = israelPrice;
 }

 public Field(ISubject parent, string sourceName, string displayName, Type type)
 {
     Subject = parent;
     SourceName = sourceName;
     DisplayName = displayName;
     DataType = type;
 }

    public void SetUp() {
      callback_ = new NopAuthCallbackHandler();
      shared_ = new Dictionary<string, string>();
      options_ = new Dictionary<string, string>();

      module_ = Mock.Create<ILoginModule>();
      Mock
        .Arrange(
          () => module_.Login(Arg.IsAny<IAuthCallbackHandler>(), subject_))
        .Returns(AuthenticationInfos.Sucessful());
      Mock
        .Arrange(() => module_.Commit(Arg.IsAny<IAuthenticationInfo>()))
        .Returns(true);
      Mock
        .Arrange(() => module_.ControlFlag)
        .Returns(LoginModuleControlFlag.Required);

      subject_ = Mock.Create<ISubject>();
      Mock
        .Arrange(() => subject_.Permissions)
        .Returns(new HashSet<IPermission>());
      Mock
        .Arrange(() => subject_.Principals)
        .Returns(new HashSet<IPrincipal>());
    }

 public void Add(ISubject subject)
 {
    if(this.DoesNotContain(subject) || subject == null)
    {
        this.subjects.Add(subject);
    }    
 }

 public void Initializing_a_dynamic_object_implementation()
 {
     _subject = (ISubject)typeof(ISubject).InitializeProxy(new
         {
             Value = _stringValue,
         });
 }

        private DenyResult[] GetDenyActions(ISubject subject, IAction[] actions, ISecurityObjectId objectId, ISecurityObjectProvider securityObjProvider)
        {
            var denyActions = new List<DenyResult>();
            if (actions == null) actions = new IAction[0];

            if (subject == null)
            {
                denyActions = actions.Select(a => new DenyResult(a, null, null)).ToList();
            }
            else if (subject is ISystemAccount && subject.ID == Constants.CoreSystem.ID)
            {
                // allow all
            }
            else
            {
                ISubject denySubject = null;
                IAction denyAction = null;
                foreach (var action in actions)
                {
                    var allow = azManager.CheckPermission(subject, action, objectId, securityObjProvider, out denySubject, out denyAction);
                    if (!allow)
                    {
                        denyActions.Add(new DenyResult(action, denySubject, denyAction));
                        break;
                    }
                }
            }
            return denyActions.ToArray();
        }

 internal static string FormatErrorMessage(ISubject subject, IAction[] actions, ISubject[] denySubjects,
                                           IAction[] denyActions)
 {
     if (subject == null) throw new ArgumentNullException("subject");
     if (actions == null || actions.Length == 0) throw new ArgumentNullException("actions");
     if (denySubjects == null || denySubjects.Length == 0) throw new ArgumentNullException("denySubjects");
     if (denyActions == null || denyActions.Length == 0) throw new ArgumentNullException("denyActions");
     if (actions.Length != denySubjects.Length || actions.Length != denyActions.Length)
         throw new ArgumentException();
     string reasons = "";
     for (int i = 0; i < actions.Length; i++)
     {
         string reason = "";
         if (denySubjects[i] != null && denyActions[i] != null)
             reason = String.Format("{0}:{1} access denied {2}.",
                                    actions[i].Name,
                                    (denySubjects[i] is IRole ? "role:" : "") + denySubjects[i].Name,
                                    denyActions[i].Name
                 );
         else
             reason = String.Format("{0}: access denied.", actions[i].Name);
         if (i != actions.Length - 1)
             reason += ", ";
         reasons += reason;
     }
     string sactions = "";
     Array.ForEach(actions, action => { sactions += action.ToString() + ", "; });
     string message = String.Format(
         "\"{0}\" access denied \"{1}\". Cause: {2}.",
         (subject is IRole ? "role:" : "") + subject.Name,
         sactions,
         reasons
         );
     return message;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="SuspensionService"/> class.
        /// Based on WinRTSuspensionHost in ReactiveUI.Mobile
        /// </summary>
        public SuspensionService(Application app, ISubject<LaunchActivatedEventArgs> launched)
        {
            var launchNew = new[] { ApplicationExecutionState.ClosedByUser, ApplicationExecutionState.NotRunning, };
            this.IsLaunchingNew = launched
                .Where(x => launchNew.Contains(x.PreviousExecutionState))
                .Select(x => x.Arguments);

            this.IsResuming = launched
                .Where(x => x.PreviousExecutionState == ApplicationExecutionState.Terminated)
                .Select(x => x.Arguments);

            var unpausing = new[] { ApplicationExecutionState.Suspended, ApplicationExecutionState.Running, };
            this.IsUnpausing = launched
                .Where(x => unpausing.Contains(x.PreviousExecutionState))
                .Select(x => x.Arguments);

            var shouldPersistState = new Subject<SuspendingEventArgs>();
            app.Suspending += (o, e) => shouldPersistState.OnNext(e);
            this.ShouldPersistState =
                shouldPersistState.Select(x =>
                {
                    var deferral = x.SuspendingOperation.GetDeferral();
                    return Disposable.Create(deferral.Complete);
                });

            var shouldInvalidateState = new Subject<Unit>();
            app.UnhandledException += (o, e) => shouldInvalidateState.OnNext(Unit.Default);
            this.ShouldInvalidateState = shouldInvalidateState;
        }

        internal void Bind(IObservablePropertyBag target, PerspexProperty property, ISubject<object> subject)
        {
            var mode = BindingMode == BindingMode.Default ?
                property.DefaultBindingMode : BindingMode;

            switch (mode)
            {
                case BindingMode.Default:
                case BindingMode.OneWay:
                    target.Bind(property, subject);
                    break;
                case BindingMode.TwoWay:
                    target.BindTwoWay(property, subject);
                    break;
                case BindingMode.OneTime:
                    target.GetObservable(Control.DataContextProperty).Subscribe(dataContext =>
                    {
                        subject.Take(1).Subscribe(x => target.SetValue(property, x));
                    });                    
                    break;
                case BindingMode.OneWayToSource:
                    target.GetObservable(property).Subscribe(subject);
                    break;
            }
        }

 public void UnSubscribe(ISubject<IObserver> topic, IObserver follower)
 {
     if (pushsubMapping.ContainsKey(topic.ToString()))
     {
         pushsubMapping[topic.ToString()].Remove(follower);
     }
 }

 public void Update(ISubject subject)
 {
     var boxFight = (BoxFight)subject;
     if (boxFight.BoxerAScore < boxFight.BoxerBScore)
     BoxerToPutMoneyOn = "I put on boxer B, better be safe!";
     else BoxerToPutMoneyOn = "I put on boxer A, better be safe!";
     Console.WriteLine("CONSERVATIVEPLAYER:{0}", BoxerToPutMoneyOn);
 }

        public IEnumerable<IRole> GetObjectRoles(ISubject account, ISecurityObjectId objectId, SecurityCallContext callContext)
        {
 
          //   Constants.Everyone
          // if (_daoFactory.GetManagerDao().GetAll(false).Contains(ASC.Core.CoreContext.UserManager.GetUsers(account.ID)))
          //   return new Action[]
            throw new NotImplementedException();
        }

 public MacroPlayer()
 {
     _iterationStartedSubject = new ScheduledSubject<int>(RxApp.DeferredScheduler);
     _stepCompletedSubject = new ScheduledSubject<int>(RxApp.DeferredScheduler);
     _stepStartedSubject = new ScheduledSubject<StepStartedInfo>(RxApp.DeferredScheduler);
     _stepProgressUpdatedSubject = new ScheduledSubject<int>(RxApp.DeferredScheduler);
 }

        public ViewModel()
        {
            Users = new ObservableCollection<UserFullInfo>();

            Countries = new ObservableCollection<Country>(countryService.GetCountries());

            UserProvider userP = new UserProvider();
            //AsyncUser = new AsyncVirtualizingCollection<UserFullInfo>(userP, 100, 30);
            AsyncUser = new AsyncVirtualizingCollection<UserFullInfo>(userP, 100, 30000);

            var usersObservable = userService.GetUsers().ToObservable();
            usersObservable.SubscribeOn(ThreadPoolScheduler.Instance).ObserveOn(DispatcherScheduler.Current).Subscribe(userInfo => Users.Add(userInfo));

            userSubject = new Subject<UserFullInfo>();
            userSubject.Subscribe(x =>
            {
                if (x == null)
                    return;
                x.CountrySubject.OnNext(x.Country);
                x.SubdivisionSubject.OnNext(x.Subdivision);
            });

            //var countrySubj = new Subject<UserFullInfo>();

            currentUser = new UserFullInfo();

            NewCommand = new RelayCommand(arg => NewMethod());
            SaveCommand = new RelayCommand(arg => SaveMethod());
            CloseComman = new RelayCommand(arg => CloseMethod());
        }