コード例 #1
0
        public INameParameterInfo FormatNameParameter()
        {
            if (!IsEvaluated)
            {
                return(NameParameterInfo.Unknown);
            }

            if (Value is IComplexParameter p)
            {
                return(new NameParameterInfo(true, _formattingService.FormatValue(Value), p.Details.VerificationStatus));
            }
            return(new NameParameterInfo(true, _formattingService.FormatValue(Value), ParameterVerificationStatus.NotApplicable));
        }
コード例 #2
0
        /// <summary>
        /// Formats <paramref name="value"/> as dictionary, where key-value pairs will be formatted in order based on key.
        /// </summary>
        public string FormatValue(object value, IValueFormattingService formattingService)
        {
            var dictionary = (IDictionary)value;
            var keyValues  = dictionary
                             .Keys
                             .Cast <object>()
                             .OrderBy(k => k)
                             .Select(key => string.Format(
                                         _pairFormat,
                                         formattingService.FormatValue(key),
                                         formattingService.FormatValue(dictionary[key])));

            return(string.Format(_containerFormat, string.Join(_separator, keyValues)));
        }
コード例 #3
0
 public override ExpectationResult Verify(T value, IValueFormattingService formattingService)
 {
     if (_predicateFn(value))
     {
         return(ExpectationResult.Success);
     }
     return(FormatFailure(formattingService, $"got: '{formattingService.FormatValue(value)}'"));
 }
コード例 #4
0
 /// <summary>
 /// Sets the actual value and performs the validation against the expectation, updating <see cref="Status"/> property.
 /// The value specified by <paramref name="value"/> parameter can be retrieved by <see cref="GetActual"/> method.
 ///
 /// If actual value is already set, an exception is thrown.
 /// </summary>
 /// <param name="value">Value to set.</param>
 /// <returns>Self.</returns>
 /// <exception cref="InvalidOperationException">Thrown when actual value is already set.</exception>
 public Verifiable <T> SetActual(T value)
 {
     if (Status != ParameterVerificationStatus.NotProvided)
     {
         throw new InvalidOperationException("Actual value has been already specified");
     }
     _exception  = null;
     _actual     = value;
     _actualText = _formattingService.FormatValue(value);
     _result     = Expectation.Verify(value, _formattingService);
     return(this);
 }
コード例 #5
0
ファイル: EqualCollection.cs プロジェクト: pskaushik/LightBDD
        public override ExpectationResult Verify(IEnumerable <T> collection, IValueFormattingService formattingService)
        {
            if (collection == null)
            {
                return(FormatFailure(formattingService, $"got: '{formattingService.FormatValue(null)}'"));
            }
            var details = new List <string>();
            var i       = 0;
            var actual  = (collection).ToArray();

            if (_expected.Length != actual.Length)
            {
                details.Add($"expected collection of {_expected.Length} item(s), but got one of {actual.Length} item(s)");
            }

            foreach (var item in actual)
            {
                if (_expected.Length > i)
                {
                    if (!Equals(_expected[i], item))
                    {
                        details.Add($"[{i}]: expected: '{formattingService.FormatValue(_expected[i])}', but got: '{formattingService.FormatValue(item)}'");
                    }
                }
                else
                {
                    details.Add($"[{i}]: surplus: '{formattingService.FormatValue(item)}'");
                }

                ++i;
            }
            for (; i < _expected.Length; ++i)
            {
                details.Add($"[{i}]: missing: '{formattingService.FormatValue(_expected[i])}'");
            }

            return(details.Any()
                ? FormatFailure(formattingService, $"got: '{formattingService.FormatValue(actual)}'", details)
                : ExpectationResult.Success);
        }
コード例 #6
0
        public override ExpectationResult Verify(IEnumerable <T> collection, IValueFormattingService formattingService)
        {
            if (collection == null)
            {
                return(FormatFailure(formattingService, $"got: '{formattingService.FormatValue(null)}'"));
            }

            var details         = new List <string>();
            var actual          = collection.ToArray();
            var remainingActual = actual.ToList();

            if (_expected.Length != actual.Length)
            {
                details.Add($"expected collection of {_expected.Length} item(s), but got one of {actual.Length} item(s)");
            }

            foreach (var value in _expected)
            {
                var index = remainingActual.IndexOf(value);
                if (index >= 0)
                {
                    remainingActual.RemoveAt(index);
                }
                else
                {
                    details.Add($"missing: '{formattingService.FormatValue(value)}'");
                }
            }

            foreach (var value in remainingActual)
            {
                details.Add($"surplus: '{formattingService.FormatValue(value)}'");
            }

            return(details.Any()
                ? FormatFailure(formattingService, $"got: '{formattingService.FormatValue(actual)}'", details)
                : ExpectationResult.Success);
        }
コード例 #7
0
        public override ExpectationResult Verify(T value, IValueFormattingService formattingService)
        {
            var details = new List <string>();

            foreach (var expectation in _expectations)
            {
                var result = expectation.Verify(value, formattingService);
                if (result)
                {
                    return(ExpectationResult.Success);
                }
                details.Add(result.Message);
            }
            return(FormatFailure(formattingService, $"got: '{formattingService.FormatValue(value)}'", details));
        }
コード例 #8
0
        public override ExpectationResult Verify(IEnumerable <TValue> collection, IValueFormattingService formattingService)
        {
            List <string> errors = new List <string>();
            int           i      = 0;

            foreach (var item in collection ?? Enumerable.Empty <TValue>())
            {
                var result = _itemExpectation.Verify(item, formattingService);
                if (result)
                {
                    return(ExpectationResult.Success);
                }
                errors.Add($"[{i++}]: {result.Message}");
            }

            return(FormatFailure(formattingService, $"got: '{formattingService.FormatValue(collection)}'", errors));
        }
コード例 #9
0
 /// <inheritdoc />
 public string Format(IValueFormattingService formattingService)
 {
     return(HasValue ? formattingService.FormatValue(Value) : "<none>");
 }
コード例 #10
0
 private ITabularParameterRow GetRow(TRow row, int index)
 {
     return(new TabularParameterRow(index, _columns.Select(x => _formattingService.FormatValue(x.GetValue(row)))));
 }
コード例 #11
0
ファイル: EqualCollection.cs プロジェクト: pskaushik/LightBDD
 public override string Format(IValueFormattingService formattingService)
 {
     return($"equals collection '{formattingService.FormatValue(_expected)}'");
 }
コード例 #12
0
 /// <summary>
 /// Formats provided <paramref name="value"/> as collection.
 /// </summary>
 public override string FormatValue(object value, IValueFormattingService formattingService)
 {
     return(string.Join(_separator, ((IEnumerable)value).Cast <object>().Select(o => string.Format(_valueFormat, formattingService.FormatValue(o)))));
 }