Пример #1
0
        public void Partition_sequence_multi_instance()
        {
            var expected = new[]
            {
                Token.Name("seq"),
                Token.Value("seqval0"),
                Token.Value("seqval1"),
                Token.Value("seqval2"),
                Token.Value("seqval3"),
                Token.Value("seqval4"),
            };

            var tokens = TokenPartitioner.PartitionTokensByType(
                new[]
            {
                Token.Name("str"), Token.Value("strvalue"), Token.Value("freevalue"),
                Token.Name("seq"), Token.Value("seqval0"), Token.Value("seqval1"),
                Token.Name("x"), Token.Value("freevalue2"),
                Token.Name("seq"), Token.Value("seqval2"), Token.Value("seqval3"),
                Token.Name("seq"), Token.Value("seqval4")
            },
                name =>
                new[] { "seq" }.Contains(name)
                        ? Maybe.Just(TypeDescriptor.Create(TargetType.Sequence, Maybe.Nothing <int>()))
                        : Maybe.Nothing <TypeDescriptor>());
            var result = tokens.Item3;  // Switch, Scalar, *Sequence*, NonOption

            var actual = result.ToArray();

            Assert.Equal(expected, actual);
        }
Пример #2
0
        public void Partition_switch_values_from_empty_token_sequence()
        {
            var expected = new Token[] { };

            var tokens = TokenPartitioner.PartitionTokensByType(
                new Token[] { },
                name =>
                new[] { "x", "switch" }.Contains(name)
                        ? Maybe.Just(TypeDescriptor.Create(TargetType.Switch, Maybe.Nothing <int>()))
                        : Maybe.Nothing <TypeDescriptor>());
            var result = tokens.Item1;  // *Switch*, Scalar, Sequence, NonOption

            expected.Should().BeEquivalentTo(result);
        }
Пример #3
0
        public void Partition_switch_values()
        {
            var expected = new [] { Token.Name("x") };

            var tokens = TokenPartitioner.PartitionTokensByType(
                new []
            {
                Token.Name("str"), Token.Value("strvalue"), Token.Value("freevalue"),
                Token.Name("x"), Token.Value("freevalue2")
            },
                name =>
                new[] { "x", "switch" }.Contains(name)
                        ? Maybe.Just(TypeDescriptor.Create(TargetType.Switch, Maybe.Nothing <int>()))
                        : Maybe.Nothing <TypeDescriptor>());
            var result = tokens.Item1;  // *Switch*, Scalar, Sequence, NonOption

            expected.Should().BeEquivalentTo(result);
        }
Пример #4
0
        public void Partition_sequence_values_only()
        {
            var expected = new[]
            {
                Token.Name("seq"), Token.Value("seqval0"), Token.Value("seqval1")
            };

            var tokens = TokenPartitioner.PartitionTokensByType(
                new[]
            {
                Token.Name("seq"), Token.Value("seqval0"), Token.Value("seqval1")
            },
                name =>
                new[] { "seq" }.Contains(name)
                        ? Maybe.Just(TypeDescriptor.Create(TargetType.Sequence, Maybe.Nothing <int>()))
                        : Maybe.Nothing <TypeDescriptor>());
            var result = tokens.Item3;  // Switch, Scalar, *Sequence*, NonOption

            expected.Should().BeEquivalentTo(result);
        }
Пример #5
0
        public void Partition_sequence_multi_instance_with_max()
        {
            var incorrect = new[]
            {
                Token.Name("seq"),
                Token.Value("seqval0"),
                Token.Value("seqval1"),
                Token.Value("seqval2"),
                Token.Value("seqval3"),
                Token.Value("seqval4"),
                Token.Value("seqval5"),
            };

            var expected = new[]
            {
                Token.Name("seq"),
                Token.Value("seqval0"),
                Token.Value("seqval1"),
                Token.Value("seqval2"),
            };

            var tokens = TokenPartitioner.PartitionTokensByType(
                new[]
            {
                Token.Name("str"), Token.Value("strvalue"), Token.Value("freevalue"),
                Token.Name("seq"), Token.Value("seqval0"), Token.Value("seqval1"),
                Token.Name("x"), Token.Value("freevalue2"),
                Token.Name("seq"), Token.Value("seqval2"), Token.Value("seqval3"),
                Token.Name("seq"), Token.Value("seqval4"), Token.Value("seqval5"),
            },
                name =>
                new[] { "seq" }.Contains(name)
                        ? Maybe.Just(TypeDescriptor.Create(TargetType.Sequence, Maybe.Just <int>(3)))
                        : Maybe.Nothing <TypeDescriptor>());
            var result = tokens.Item3;  // Switch, Scalar, *Sequence*, NonOption

            // Max of 3 will apply to the total values, so there should only be 3 values, not 6
            Assert.NotEqual(incorrect, result);
            Assert.Equal(expected, result);
        }