RegExParserTest.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.var.crossfire.model.validation.checks;
 
import java.awt.Point;
import net.sf.gridarta.model.archetype.TestArchetype;
import net.sf.gridarta.model.gameobject.TestGameObject;
import net.sf.gridarta.model.maparchobject.TestMapArchObject;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.TestMapModelCreator;
import net.sf.gridarta.model.validation.DefaultErrorCollector;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.model.validation.errors.ValidationError;
import net.sf.gridarta.var.crossfire.model.validation.errors.SuspiciousMsgRegExError;
import org.jetbrains.annotations.NotNull;
import org.junit.Assert;
import org.junit.Test;
 
@SuppressWarnings("JavaDoc")
public class RegExParserTest {
 
    @Test
    public void validateRegEx_nonAsciiCharacter1_reportsError() {
        Assert.assertEquals("" + //
            "non-ASCII character" + //
            "", validateRegExErrors("ö"));
    }
 
    @Test
    public void validateRegEx_nonAsciiCharacter2_reportsError() {
        Assert.assertEquals("" + //
            "non-ASCII character" + //
            "", validateRegExErrors("\u001F"));
    }
 
    @Test
    public void validateRegEx_negatedCharacterRange_reportsError() {
        Assert.assertEquals("" + //
            "negated character range" + //
            "", validateRegExErrors("[^a]"));
    }
 
    @Test
    public void validateRegEx_unterminatedCharacterRange1_reportsError() {
        Assert.assertEquals("" + //
            "unterminated character range" + //
            "", validateRegExErrors("["));
    }
 
    @Test
    public void validateRegEx_unterminatedCharacterRange2_reportsError() {
        Assert.assertEquals("" + //
            "unterminated character range" + //
            "", validateRegExErrors("[abc"));
    }
 
    @Test
    public void validateRegEx_unterminatedCharacterRange3_reportsError() {
        Assert.assertEquals("" + //
            "unterminated character range" + //
            "", validateRegExErrors("[-"));
    }
 
    @Test
    public void validateRegEx_unterminatedCharacterRange4_reportsError() {
        Assert.assertEquals("" + //
            "unterminated character range" + //
            "", validateRegExErrors("[a-"));
    }
 
    @Test
    public void validateRegEx_trailingMinusInCharacterRange_reportsError() {
        Assert.assertEquals("" + //
            "confusing trailing '-' in character range" + //
            "", validateRegExErrors("[a-]"));
    }
 
    @Test
    public void validateRegEx_invalidCharacterRange1_reportsError() {
        Assert.assertEquals("" + //
            "character ranges should use only a-z, A-Z, or 0-9" + //
            "the word '[a-B]' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only" + //
            "", validateRegExErrors("[a-B]"));
    }
 
    @Test
    public void validateRegEx_invalidCharacterRange2_reportsError() {
        Assert.assertEquals("" + //
            "character ranges should use only a-z, A-Z, or 0-9" + //
            "", validateRegExErrors("[0-a]"));
    }
 
    @Test
    public void validateRegEx_lowerCaseLetterCharacterRange_reportsOk() {
        Assert.assertEquals("", validateRegExErrors("[a-z]"));
    }
 
    @Test
    public void validateRegEx_upperCaseLetterCharacterRange_reportsError() {
        Assert.assertEquals("" + //
            "the word '[A-Z]' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only" + //
            "", validateRegExErrors("[A-Z]"));
    }
 
    @Test
    public void validateRegEx_digitCharacterRange_reportsOk() {
        Assert.assertEquals("", validateRegExErrors("[0-9]"));
    }
 
    @Test
    public void validateRegEx_backwardCharacterRange1_reportsError() {
        Assert.assertEquals("" + //
            "invalid character range" + //
            "", validateRegExErrors("[b-a]"));
    }
 
    @Test
    public void validateRegEx_backwardCharacterRange2_reportsError() {
        Assert.assertEquals("" + //
                "invalid character range" + //
                "the word '[B-A]' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only", //
            validateRegExErrors("[B-A]"));
    }
 
    @Test
    public void validateRegEx_backwardCharacterRange3_reportsError() {
        Assert.assertEquals("" + //
            "invalid character range" + //
            "", validateRegExErrors("[1-0]"));
    }
 
    @Test
    public void validateRegEx_singleCharacterInCharacterRange1_reportsError() {
        Assert.assertEquals("" + //
            "single-character character range" + //
            "", validateRegExErrors("[a-a]"));
    }
 
    @Test
    public void validateRegEx_singleCharacterInCharacterRange2_reportsError() {
        Assert.assertEquals("" + //
            "single-character character range" + //
            "", validateRegExErrors("[a-a]"));
    }
 
    @Test
    public void validateRegEx_duplicateCharacterInCharacterRange1_reportsError() {
        Assert.assertEquals("" + //
            "duplicate character 'a' in character range" + //
            "", validateRegExErrors("[aa]"));
    }
 
    @Test
    public void validateRegEx_duplicateCharacterInCharacterRange2_reportsError() {
        Assert.assertEquals("" + //
            "duplicate character 'b' in character range" + //
            "", validateRegExErrors("[abcbd]"));
    }
 
    @Test
    public void validateRegEx_duplicateCharacterInCharacterRange3_reportsError() {
        Assert.assertEquals("" + //
            "duplicate character 'b' in character range" + //
            "", validateRegExErrors("[a-cb]"));
    }
 
    @Test
    public void validateRegEx_duplicateCharacterInCharacterRange4_reportsError() {
        Assert.assertEquals("" + //
            "duplicate character 'b' in character range" + //
            "", validateRegExErrors("[ba-c]"));
    }
 
    @Test
    public void validateRegEx_duplicateCharacterInCharacterRange5_reportsError() {
        Assert.assertEquals("" + //
            "duplicate character 'c' in character range" + //
            "", validateRegExErrors("[a-ec-f]"));
    }
 
    @Test
    public void validateRegEx_emptyCharacterRange_reportsError() {
        Assert.assertEquals("" + //
            "empty character range" + //
            "", validateRegExErrors("[]"));
    }
 
    @Test
    public void validateRegEx_singleCharCharacterRange_reportsError() {
        Assert.assertEquals("" + //
            "the word 'ant[s]' is the same as 'ants' which is probably not what was intended" + //
            "", validateRegExErrors("ant[s]"));
    }
 
    @Test
    public void validateRegEx_trailingBackslash_reportsError() {
        Assert.assertEquals("" + //
            "trailing \\" + //
            "", validateRegExErrors("abc\\"));
    }
 
    @Test
    public void validateRegEx_operator1_reportsError() {
        Assert.assertEquals("" + //
            "use of regular expression operator '?'. This is usually not useful and therefore should be avoided" + //
            "", validateRegExErrors("a?"));
    }
 
    @Test
    public void validateRegEx_operator2_reportsError() {
        Assert.assertEquals("" + //
            "use of regular expression operator '*'. This is usually not useful and therefore should be avoided" + //
            "", validateRegExErrors("a*"));
    }
 
    @Test
    public void validateRegEx_operator3_reportsError() {
        Assert.assertEquals("" + //
            "use of regular expression operator '+'. This is usually not useful and therefore should be avoided" + //
            "", validateRegExErrors("a+"));
    }
 
    @Test
    public void validateRegEx_operator4_reportsError() {
        Assert.assertEquals("" + //
            "use of regular expression operator '.'. This is usually not useful and therefore should be avoided" + //
            "", validateRegExErrors("a."));
    }
 
    @Test
    public void validateRegEx_operator5_reportsError() {
        Assert.assertEquals("" + //
            "use of regular expression operator '\\'. This is usually not useful and therefore should be avoided" + //
            "", validateRegExErrors("a\\."));
    }
 
    @Test
    public void validateRegEx_beginOperator_reportsOk() {
        Assert.assertEquals("", validateRegExErrors("^a"));
    }
 
    @Test
    public void validateRegEx_quotedBeginOperator_reportsOk() {
        Assert.assertEquals("", validateRegExErrors("a[a^]"));
    }
 
    @Test
    public void validateRegEx_beginOperatorNotAtStart1_reportsError() {
        Assert.assertEquals("" + //
            "the regular expression operator '^' must be used at the start of the word" + //
            "", validateRegExErrors("a^"));
    }
 
    @Test
    public void validateRegEx_beginOperatorNotAtStart2_reportsError() {
        Assert.assertEquals("" + //
            "the regular expression operator '^' must be used at the start of the word" + //
            "", validateRegExErrors("a^a"));
    }
 
    @Test
    public void validateRegEx_endOperator_reportsOk() {
        Assert.assertEquals("", validateRegExErrors("a$"));
    }
 
    @Test
    public void validateRegEx_quotedEndOperator_reportsOk() {
        Assert.assertEquals("", validateRegExErrors("[$a]a"));
    }
 
    @Test
    public void validateRegEx_endOperatorNotAtEnd1_reportsError() {
        Assert.assertEquals("" + //
            "the regular expression operator '$' must be used at the end of the word" + //
            "", validateRegExErrors("$a"));
    }
 
    @Test
    public void validateRegEx_endOperatorNotAtEnd2_reportsError() {
        Assert.assertEquals("" + //
            "the regular expression operator '$' must be used at the end of the word" + //
            "", validateRegExErrors("a$a"));
    }
 
    @Test
    public void validateRegEx_wordWithLeadingSpace1_reportsError() {
        Assert.assertEquals("" + //
            "the word ' word' starts with a space" + //
            "", validateRegExErrors(" word"));
    }
 
    @Test
    public void validateRegEx_wordWithLeadingSpace2_reportsError() {
        Assert.assertEquals("" + //
            "the word ' word2' starts with a space" + //
            "", validateRegExErrors("word1| word2"));
    }
 
    @Test
    public void validateRegEx_wordWithTrailingSpace1_reportsError() {
        Assert.assertEquals("" + //
            "the word 'word ' ends with a space" + //
            "", validateRegExErrors("word "));
    }
 
    @Test
    public void validateRegEx_wordWithTrailingSpace2_reportsError() {
        Assert.assertEquals("" + //
            "the word 'word1 ' ends with a space" + //
            "", validateRegExErrors("word1 |word2"));
    }
 
    @Test
    public void validateRegEx_wordWithLeadingAndTrailingSpace_reportsError() {
        Assert.assertEquals("" + //
            "the word 'word1 ' ends with a space" + //
            "the word ' word2' starts with a space" + //
            "", validateRegExErrors("word1 | word2"));
    }
 
    @Test
    public void validateRegEx_wordWithUpperCaseLetter_reportsError() {
        Assert.assertEquals("" + //
            "the word 'hEllo' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only" + //
            "", validateRegExErrors("hi|hEllo"));
    }
 
    @NotNull
    private static String validateRegExErrors(@NotNull final String regEx) {
        final RegExParser parser = new RegExParser();
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        final ErrorCollector<TestGameObject, TestMapArchObject, TestArchetype> errorCollector = new DefaultErrorCollector<>();
        final TestGameObject gameObject = creator.newGameObject("test", "name");
        final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = creator.newMapModel(1, 1);
        mapModel.beginTransaction("test");
        try {
            mapModel.addGameObjectToMap(gameObject, new Point(0, 0), creator.getTopmostInsertionMode());
        } finally {
            mapModel.endTransaction();
        }
        final ErrorGenerator<?, ?, ?> generator = new ErrorGenerator<>(errorCollector, gameObject);
        parser.parse(regEx, generator);
        final StringBuilder sb = new StringBuilder();
        for (final ValidationError<TestGameObject, TestMapArchObject, TestArchetype> error : errorCollector.getErrors()) {
            if (error instanceof SuspiciousMsgRegExError) {
                sb.append(error.getParameter(1));
            } else {
                Assert.fail("invalid validation error: " + error.getClass().getName() + ":" + error);
            }
        }
        return sb.toString();
    }
 
}