public void Parse_NullS_ThrowsArgumentNullException()
        {
            var parser = new TileStateParser();

            // ReSharper disable once AssignNullToNotNullAttribute
            Assert.That(() => parser.Parse(null), Throws.ArgumentNullException);
        }
        public void Parse(string s, byte expectedType, bool expectedValue)
        {
            var parser = new TileStateParser();
            var tile   = new Tile();

            var state = parser.Parse(s);

            Assert.That(state, Is.Not.Null);
            tile = state.Apply(tile);
            Assert.That(GetValue(tile, expectedType), Is.EqualTo(expectedValue));
        }
        public void Parse_InvalidTileState_ReturnsNull(string s)
        {
            var parser = new TileStateParser();

            Assert.That(parser.Parse(s), Is.Null);
        }
Beispiel #4
0
        private void Mask(CommandArgs args)
        {
            var parameters = args.Parameters;
            var player     = args.Player;

            if (parameters.Count == 0 || parameters.Count == 2)
            {
                player.SendErrorMessage("Syntax: //mask <mask>");
                return;
            }

            var  session = Plugin.GetOrCreateSession(player);
            Mask mask;

            if (parameters.Count == 1)
            {
                var inputMask = parameters[0];
                if (inputMask.Equals("#none", StringComparison.OrdinalIgnoreCase))
                {
                    mask = new EmptyMask();
                }
                else if (inputMask.Equals("#selection", StringComparison.OrdinalIgnoreCase))
                {
                    mask = new RegionMask(session.Selection);
                }
                else
                {
                    var state = new TileStateParser().Parse(inputMask);
                    if (state == null)
                    {
                        player.SendErrorMessage($"Invalid state '{inputMask}'.");
                        return;
                    }

                    mask = new TemplateMask(state);
                }
            }
            else
            {
                var inputType = parameters[0];
                if (!Parsers.TryGetValue(inputType, out var parser))
                {
                    player.SendErrorMessage($"Invalid mask type '{inputType}'.");
                    return;
                }

                var inputComparison = parameters[1];
                var negated         = false;
                if (inputComparison.Equals("!=", StringComparison.OrdinalIgnoreCase))
                {
                    negated = true;
                }
                else if (!inputComparison.Equals("=", StringComparison.OrdinalIgnoreCase))
                {
                    player.SendErrorMessage($"Invalid mask comparison '{inputComparison}'.");
                    return;
                }

                var inputPattern = string.Join(" ", parameters.Skip(2));
                var pattern      = parser.Parse(inputPattern);
                if (pattern == null)
                {
                    player.SendErrorMessage($"Invalid pattern '{inputPattern}'.");
                    return;
                }

                mask = new TemplateMask(pattern);
                if (negated)
                {
                    mask = new NegatedMask(mask);
                }
            }

            session.Mask = mask;
            player.SendSuccessMessage("Set mask.");
        }