Information describing an error.
Inheritance: IErrorInfo
        public void ShouldReplaceError()
        {
            var error1 = new ErrorInfo { ErrorCode = 1 };
            var error2 = new ErrorInfo { ErrorCode = 1 };

            mock.AddError(m => m.Text, error1);
            var errors = mock.GetErrors<Mock>(m => m.Text);
            errors.Count().ShouldBe(1);
            errors.First().ShouldBe(error1);

            mock.AddError(m => m.Text, error2);
            errors = mock.GetErrors<Mock>(m => m.Text);
            errors.Count().ShouldBe(1);
            errors.First().ShouldBe(error2);

            mock.AddError(m => m.Text, error1);
            errors = mock.GetErrors<Mock>(m => m.Text);
            errors.Count().ShouldBe(1);
            errors.First().ShouldBe(error1);
        }
        public void ShouldFireWhenRemovingSingleError()
        {
            var error1 = new ErrorInfo { ErrorCode = 1 };
            mock.AddError(m => m.Number, error1);

            var fireCount = 0;
            mock.ErrorsChanged += delegate { fireCount++; };

            mock.RemoveError(m => m.Number, error1.ErrorCode);
            fireCount.ShouldBe(1);

            fireCount = 0;
            mock.RemoveError(m => m.Number, error1.ErrorCode);
            fireCount.ShouldBe(0);
        }
        public void ShouldRemoveAllErrorsFromProperty()
        {
            var error1 = new ErrorInfo { ErrorCode = 1 };
            var error2 = new ErrorInfo { ErrorCode = 2 };

            mock.AddError(m => m.Number, error1);
            mock.AddError(m => m.Number, error2);

            var fireCount = 0;
            mock.ErrorsChanged += delegate { fireCount++; };

            mock.GetErrors<Mock>(m => m.Number).Count().ShouldBe(2);

            // ---

            mock.ClearErrors(m => m.Number);
            mock.GetErrors<Mock>(m => m.Number).Count().ShouldBe(0);
            fireCount.ShouldBe(1);

            mock.ClearErrors(m => m.Number);
            fireCount.ShouldBe(1);
        }
        public void ShouldRemoveSpecficErrorFromProperty()
        {
            var error1 = new ErrorInfo { ErrorCode = 1 };
            var error2 = new ErrorInfo { ErrorCode = 2 };

            mock.AddError(m => m.Number, error1);
            mock.AddError(m => m.Number, error2);
            var errors = mock.GetErrors<Mock>(m => m.Number);
            errors.Count().ShouldBe(2);
            errors.ShouldContain(error1);
            errors.ShouldContain(error2);

            mock.RemoveError(m => m.Number, error2.ErrorCode);
            errors = mock.GetErrors<Mock>(m => m.Number);
            errors.Count().ShouldBe(1);
            errors.ShouldContain(error1);
            errors.ShouldNotContain(error2);
        }
        public void ShouldAllowSameErrorToExistForDifferentProperties()
        {
            var error1 = new ErrorInfo { ErrorCode = 1 };

            mock.AddError(m => m.Text, error1);
            mock.AddError(m => m.Number, error1);

            var errors = mock.GetErrors();
            errors.Count().ShouldBe(2);

            mock.GetErrors<Mock>(m => m.Text).First().ShouldBe(error1);
            mock.GetErrors<Mock>(m => m.Number).First().ShouldBe(error1);
            mock.GetErrors<Mock>(m => m.Date).Count().ShouldBe(0);
        }
        public void ShouldFireEvent()
        {
            var fireCount = 0;
            mock.ErrorsChanged += delegate { fireCount++; };

            var error1 = new ErrorInfo { ErrorCode = 1 };
            var error2 = new ErrorInfo { ErrorCode = 2 };

            mock.AddError(m => m.Number, error1);
            fireCount.ShouldBe(1);

            mock.AddError(m => m.Number, error2);
            fireCount.ShouldBe(2);

            mock.AddError(m => m.Text, error2);
            fireCount.ShouldBe(3);
        }
 public void ShouldNotReturnErrorForProperty()
 {
     var error1 = new ErrorInfo { ErrorCode = 1 };
     mock.AddError(m => m.Text, error1);
     mock.GetErrors<Mock>(m => m.Number).Count().ShouldBe(0);
 }
        public void ShouldAddMulipleErrorsInOrder()
        {
            var error1 = new ErrorInfo { ErrorCode = 1 };
            var error2 = new ErrorInfo { ErrorCode = 2 };

            mock.AddError(m => m.Text, error1);
            mock.AddError(m => m.Text, error2);

            var errors = mock.GetErrors<Mock>(m => m.Text);
            errors.ElementAt(0).ShouldBe(error1);
            errors.ElementAt(1).ShouldBe(error2);
        }