public static void NoCustomExceptionThrown()
    {
        var collection = new List <int> {
            42
        };

        collection.MustNotBeNullOrEmpty(_ => new Exception()).Should().BeSameAs(collection);
    }
        public void ListNull()
        {
            List <string> list = null;

            // ReSharper disable once ExpressionIsAlwaysNull
            Action act = () => list.MustNotBeNullOrEmpty(nameof(list));

            act.ShouldThrow <ArgumentNullException>()
            .And.ParamName.Should().Be(nameof(list));
        }
        public void ListEmpty()
        {
            // ReSharper disable once CollectionNeverUpdated.Local
            var list = new List <int>();

            Action act = () => list.MustNotBeNullOrEmpty(nameof(list));

            act.ShouldThrow <EmptyCollectionException>()
            .And.ParamName.Should().Be(nameof(list));
        }
    public static void CollectionEmpty()
    {
        var empty = new List <double>();

        Action act = () => empty.MustNotBeNullOrEmpty(nameof(empty));

        var assertion = act.Should().Throw <EmptyCollectionException>().Which;

        assertion.Message.Should().Contain($"{nameof(empty)} must not be an empty collection, but it actually is.");
        assertion.ParamName.Should().BeSameAs(nameof(empty));
    }
 public Drink(Guid id,
              string name,
              List <DrinkComponent> components,
              string instructions,
              string origin,
              List <Flavour> flavours = null) : base(id)
 {
     Name         = name.MustNotBeNull(nameof(name));
     Components   = components.MustNotBeNullOrEmpty(nameof(components));
     Instructions = instructions.MustNotBeNullOrWhiteSpace(nameof(instructions));
     Origin       = origin.MustBeOneOf(Origins.All);
     Flavours     = flavours ?? new List <Flavour>();
 }
示例#6
0
        public static Dictionary <int, List <int> > DistributeSequencePerCpuCore(List <int> sequence)
        {
            sequence.MustNotBeNullOrEmpty();

            var numberOfProcessors = Environment.ProcessorCount;
            var perThreadSequences = new Dictionary <int, List <int> >();

            for (var i = 0; i < numberOfProcessors; i++)
            {
                perThreadSequences.Add(i, new List <int>());
            }

            for (var i = 0; i < sequence.Count; i++)
            {
                var targetGroup = i % numberOfProcessors;
                perThreadSequences[targetGroup].Add(sequence[i]);
            }

            return(perThreadSequences);
        }
        public void ListNotEmpty(List <int> list)
        {
            var result = list.MustNotBeNullOrEmpty(nameof(list));

            result.Should().BeSameAs(list);
        }
示例#8
0
 public List <string> LightGuardClauses() => Collection.MustNotBeNullOrEmpty(nameof(Collection));
示例#9
0
            public void ShouldThrowArgumentExceptionWhen_param_IsEmpty()
            {
                // Given
                var param = new List<int>();

                // When
                Action action = () => param.MustNotBeNullOrEmpty("fakeParamName");

                // Then
                action
                    .ShouldThrow<ArgumentException>()
                    .WithMessage("Value cannot be empty.\r\nParameter name: fakeParamName");
            }
示例#10
0
            public void ShouldReturn_param_When_param_IsNotNull()
            {
                // Given
                var param = new List<int>(new[] { 1, 2 });

                // When
                var value = param.MustNotBeNullOrEmpty("fakeParamName");

                // Then
                value.Should().BeEquivalentTo(param);
            }