SuspiciousMsgCheckerTest.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.DuplicateArchetypeException;
import net.sf.gridarta.model.archetype.TestArchetype;
import net.sf.gridarta.model.baseobject.BaseObject;
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.GameObjectValidator;
import net.sf.gridarta.model.validation.TestValidatorPreferences;
import net.sf.gridarta.model.validation.errors.ValidationError;
import net.sf.gridarta.var.crossfire.model.archetype.Archetype;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
 
@SuppressWarnings("JavaDoc")
public class SuspiciousMsgCheckerTest {
 
    @BeforeClass
    public static void setUp() {
        final ActionBuilder actionBuilder = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");
        actionBuilder.addParent(ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta.var.crossfire"));
    }
 
    @Test
    public void validateGameObject_noMsg_reportsNoError() {
        Assert.assertNull(validate(null));
    }
 
    @Test
    public void validateGameObject_normalMsg_reportsNoError() {
        Assert.assertNull(validate("some text"));
    }
 
    @Test
    public void validateGameObject_validMatchMsg_reportsNoError() {
        Assert.assertNull(validate("@match hi\n" + "1"));
    }
 
    @Test
    public void validateGameObject_suspiciousMatchMsg1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[match hi][a text line starts with 'match'. Maybe '@match' was intended?]" + //
            "SuspiciousMsgSyntaxError[match hi][text before @match]" + //
            "", validate("match hi\n" + "1"));
    }
 
    @Test
    public void validateGameObject_suspiciousMatchMsg2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[match@ hi][a text line starts with 'match'. Maybe '@match' was intended?]" + //
            "SuspiciousMsgSyntaxError[match@ hi][text before @match]" + //
            "", validate("match@ hi\n" + "1"));
    }
 
    @Test
    public void validateGameObject_suspiciousMatchMsg3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[match ho][a text line starts with 'match'. Maybe '@match' was intended?]" + //
            "", validate("@match hi\n" + "1\n" + "match ho\n" + "2\n" + "@match *\n" + "3"));
    }
 
    @Test
    public void validateGameObject_matchExcessSpace1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match  hi][the word ' hi' starts with a space]" + //
            "", validate("@match  hi\n" + "1"));
    }
 
    @Test
    public void validateGameObject_matchExcessSpace2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match hi| hello][the word ' hello' starts with a space]" + //
            "", validate("@match hi| hello\n" + "1"));
    }
 
    @Test
    public void validateGameObject_matchExcessSpace3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match hi |hello][the word 'hi ' ends with a space]" + //
            "", validate("@match hi |hello\n" + "1"));
    }
 
    @Test
    public void validateGameObject_replyExcessSpace1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@reply  a b][the keyword ' a' after '@reply' starts with a space]" + //
            "", validate("@match a\n" + "1\n" + "@reply  a b"));
    }
 
    @Test
    public void validateGameObject_replyExcessSpace2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@reply  a b][the keyword ' a' after '@reply' starts with a space]" + //
            "", validate("@match a\n" + "1\n" + "@reply  a b"));
    }
 
    @Test
    public void validateGameObject_questionExcessSpace1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@question  a b][the keyword ' a' after '@question' starts with a space]" + //
            "", validate("@match a\n" + "1\n" + "@question  a b"));
    }
 
    @Test
    public void validateGameObject_questionExcessSpace2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@question  a b][the keyword ' a' after '@question' starts with a space]" + //
            "", validate("@match a\n" + "1\n" + "@question  a b"));
    }
 
    @Test
    public void validateGameObject_singleEmptyLine_reportsNoError() {
        Assert.assertNull(validate("@match hi\n" + "1\n" + "\n" + "2"));
    }
 
    @Test
    public void validateGameObject_duplicateEmptyLine_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[][the text contains more than one consecutive empty line]" + //
            "", validate("@match hi\n" + "1\n" + "\n" + "\n" + "2"));
    }
 
    @Test
    public void validateGameObject_leadingEmptyLine_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[][the text starts with an empty line]" + //
            "", validate("@match hi\n" + "\n" + "2"));
    }
 
    @Test
    public void validateGameObject_trailingEmptyLine_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[][the text ends with an empty line]" + //
            "", validate("@match hi\n" + "1\n" + "\n"));
    }
 
    @Test
    public void validateGameObject_upperCaseCharacter1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match Hi][the word 'Hi' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only]" + //
            "", validate("@match Hi\n" + "1\n"));
    }
 
    @Test
    public void validateGameObject_upperCaseCharacter2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match hi|hEllo][the word 'hEllo' checks for upper-case letters. Matches are case-insensitive, therefore matches should be specified in lower-case letters only]" + //
            "", validate("@match hi|hEllo\n" + "1\n"));
    }
 
    @Test
    public void validateGameObject_upperCaseCharacter3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@reply A a][the word 'A' uses upper-case letters. Matches are case-insensitive, therefore replies and questions should be specified in lower-case letters only]" + //
            "", validate("@match a\n" + "1\n" + "@reply A a\n"));
    }
 
    @Test
    public void validateGameObject_upperCaseCharacter4_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@question A a][the word 'A' uses upper-case letters. Matches are case-insensitive, therefore replies and questions should be specified in lower-case letters only]" + //
            "", validate("@match a\n" + "1\n" + "@question A a\n"));
    }
 
    @Test
    public void validateGameObject_regexCharacter1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match a?][use of regular expression operator '?'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match a?\n" + "1"));
    }
 
    @Test
    public void validateGameObject_regexCharacter2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match a*][use of regular expression operator '*'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match a*\n" + "1"));
    }
 
    @Test
    public void validateGameObject_regexCharacter3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match a+][use of regular expression operator '+'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match a+\n" + "1"));
    }
 
    @Test
    public void validateGameObject_regexCharacter4_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match a.][use of regular expression operator '.'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match a.\n" + "1"));
    }
 
    @Test
    public void validateGameObject_regexCharacter5_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match \\a][use of regular expression operator '\\'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match \\a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_starNotAtStartOfLine_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match b|*a][use of regular expression operator '*'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match b|*a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_wrongKeyword_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@xyz][unrecognized keyword: '@xyz']" + //
            "", validate("@match a\n" + "@xyz\n" + "1"));
    }
 
    @Test
    public void validateGameObject_textBeforeFirstEntry_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[text][text before @match]" + //
            "", validate("text\n" + "@match a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_replyWithoutMatch_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply a b][@reply or @question without @match]" + //
            "SuspiciousMsgSyntaxError[1][text before @match]" + //
            "SuspiciousMsgKeywordError[1][keyword 'a' in '@reply' does not appear in any @match line]" + //
            "", validate("@reply a b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_questionWithoutMatch1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question a b][@reply or @question without @match]" + //
            "SuspiciousMsgSyntaxError[1][text before @match]" + //
            "SuspiciousMsgKeywordError[1][keyword 'a' in '@question' does not appear in any @match line]" + //
            "", validate("@question a b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_regExSyntaxError1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match [][unterminated character range]" + //
            "", validate("@match [\n" + "1"));
    }
 
    @Test
    public void validateGameObject_emptyWord2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match a|][empty keyword in '@match']" + //
            "", validate("@match a|\n" + "1"));
    }
 
    @Test
    public void validateGameObject_emptyWord3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match |a][empty keyword in '@match']" + //
            "", validate("@match |a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_emptyWord4_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match a||b][empty keyword in '@match']" + //
            "", validate("@match a||b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_wordBeginsWithStar1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgMatchAllTextError[@match *a][null]" + //
            "", validate("@match *a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_wordBeginsWithStar2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match a|*a][use of regular expression operator '*'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match a|*a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_duplicateWord1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match a|a][duplicate keyword 'a' in '@match'. The second one will never match]" + //
            "", validate("@match a|a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_duplicateWord2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match a|b|a][duplicate keyword 'a' in '@match'. The second one will never match]" + //
            "", validate("@match a|b|a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_duplicateWord3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match a][duplicate keyword 'a' in '@match'. The second one will never match]" + //
            "", validate("@match a\n" + "1\n" + "@match a\n" + "2"));
    }
 
    @Test
    public void validateGameObject_duplicateWord4_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match c|d|e][duplicate keyword 'd' in '@match'. The second one will never match]" + //
            "", validate("@match a|b|d\n" + "1\n" + "@match c|d|e\n" + "2"));
    }
 
    @Test
    public void validateGameObject_matchAllNotAtEnd1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgMatchAllTextError[@match *|a][null]" + //
            "", validate("@match *|a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_matchAllNotAtEnd2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match a][keyword 'a' in '@match' after '@match *'. The keyword will never match]" + //
            "", validate("@match *\n" + "1\n" + "@match a\n" + "2"));
    }
 
    @Test
    public void validateGameObject_matchAllNotAtEnd3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@match *][duplicate '@match *'. The second one will never match]" + //
            "", validate("@match *\n" + "1\n" + "@match *\n" + "2"));
    }
 
    @Test
    public void validateGameObject_starNotAlone_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgRegExError[@match a|*][use of regular expression operator '*'. This is usually not useful and therefore should be avoided]" + //
            "", validate("@match a|*\n" + "1"));
    }
 
    @Test
    public void validateGameObject_missingMatch1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply a b][@reply or @question without @match]" + //
            "SuspiciousMsgSyntaxError[1][text before @match]" + //
            "SuspiciousMsgKeywordError[1][keyword 'a' in '@reply' does not appear in any @match line]" + //
            "", validate("@reply a b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_missingMatch2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question a b][@reply or @question without @match]" + //
            "SuspiciousMsgKeywordError[@question a b][keyword 'a' in '@question' does not appear in any @match line]" + //
            "", validate("@question a b"));
    }
 
    @Test
    public void validateGameObject_missingMatch3_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply a b][@reply or @question without @match]" + //
            "", validate("@reply a b\n" + "@match a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_missingMatch4_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question a b][@reply or @question without @match]" + //
            "", validate("@question a b\n" + "@match a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_textAfterReply_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[1][text after @reply or @question]" + //
            "", validate("@match a\n" + "1\n" + "@reply a b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_textAfterQuestion_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[1][text after @reply or @question]" + //
            "", validate("@match a\n" + "1\n" + "@question a b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_valid1_reportsNoError() {
        Assert.assertNull(validate("@match a\n" + "1\n" + "@reply a b\n" + "@match b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_valid2_reportsNoError() {
        Assert.assertNull(validate("@match a\n" + "1\n" + "@question a b\n" + "@match b\n" + "1"));
    }
 
    @Test
    public void validateGameObject_emptyReply1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply][missing keyword after '@reply']" + //
            "", validate("@match a\n" + "1\n" + "@reply"));
    }
 
    @Test
    public void validateGameObject_emptyQuestion_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question][missing keyword after '@question']" + //
            "", validate("@match a\n" + "1\n" + "@question"));
    }
 
    @Test
    public void validateGameObject_replyStartsWithSpace_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@reply  a b][the keyword ' a' after '@reply' starts with a space]" + //
            "", validate("@match a\n" + "1\n" + "@reply  a b"));
    }
 
    @Test
    public void validateGameObject_questionStartsWithSpace_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@question  a b][the keyword ' a' after '@question' starts with a space]" + //
            "", validate("@match a\n" + "1\n" + "@question  a b"));
    }
 
    @Test
    public void validateGameObject_textStartsWithEmptyLine_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[][the text starts with an empty line]" + //
            "", validate("@match a\n" + "\n" + "1"));
    }
 
    @Test
    public void validateGameObject_textEndsWithEmptyLine_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@match b][@match without following text]" + //
            "", validate("@match a\n" + "1\n" + "@match b"));
    }
 
    @Test
    public void validateGameObject_textContainsEmptyLine_reportsNoError() {
        Assert.assertNull(validate("@match a\n" + "1\n" + "\n" + "2"));
    }
 
    @Test
    public void validateGameObject_textContainsMultipleEmptyLines_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[][the text contains more than one consecutive empty line]" + //
            "", validate("@match a\n" + "1\n" + "\n" + "\n" + "2"));
    }
 
    @Test
    public void validateGameObject_textContainsLeadingMatch1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[match a][a text line starts with 'match'. Maybe '@match' was intended?]" + //
            "SuspiciousMsgSyntaxError[match a][text before @match]" + //
            "", validate("match a\n" + "1"));
    }
 
    @Test
    public void validateGameObject_textContainsLeadingMatch2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[match b][a text line starts with 'match'. Maybe '@match' was intended?]" + //
            "", validate("@match a\n" + "1\n" + "match b"));
    }
 
    @Test
    public void validateGameObject_matchIncomplete_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@match][missing keywords after '@match']" + //
            "", validate("@match\n" + "1"));
    }
 
    @Test
    public void validateGameObject_replyIncomplete1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply][missing keyword after '@reply']" + //
            "", validate("@match a\n" + "1\n" + "@reply"));
    }
 
    @Test
    public void validateGameObject_replyIncomplete2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply a][missing text after '@reply']" + //
            "", validate("@match a\n" + "1\n" + "@reply a"));
    }
 
    @Test
    public void validateGameObject_questionIncomplete1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question][missing keyword after '@question']" + //
            "", validate("@match a\n" + "1\n" + "@question\n"));
    }
 
    @Test
    public void validateGameObject_questionIncomplete2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question a][missing text after '@question']" + //
            "", validate("@match a\n" + "1\n" + "@question a"));
    }
 
    @Test
    public void validateGameObject_nonMagicEarWithoutText_reportsError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@match hi][@match without following text]" + //
            "", validate(0, "@match hi", creator));
    }
 
    @Test
    public void validateGameObject_magicEarWithoutMsg_reportsNoError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertNull(validate(Archetype.TYPE_MAGIC_EAR, "@match hi", creator));
    }
 
    @Test
    public void validateGameObject_nonMagicEarWithoutMsg_reportsNoError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertNull(validate(0, null, creator));
    }
 
    @Test
    public void validateGameObject_magicEarWithoutMsg1_reportsError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertEquals("" + //
            "SuspiciousMsgMagicEarWithoutMessageError[][null]" + //
            "", validate(Archetype.TYPE_MAGIC_EAR, null, creator));
    }
 
    @Test
    public void validateGameObject_magicEarWithoutMsg2_reportsError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertEquals("" + //
            "SuspiciousMsgMagicEarWithoutMessageError[][null]" + //
            "", validate(Archetype.TYPE_MAGIC_EAR, "", creator));
    }
 
    @Test
    public void validateGameObject_magicEarWithMsg_reportsNoError() throws DuplicateArchetypeException {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        final TestArchetype archetype = creator.newArchetype("test");
        archetype.setAttributeInt(BaseObject.TYPE, Archetype.TYPE_MAGIC_EAR);
        archetype.setMsgText("@match hi");
        creator.getArchetypeSet().addArchetype(archetype);
        Assert.assertNull(validate(Archetype.TYPE_MAGIC_EAR, null, creator));
    }
 
    @Test
    public void validateGameObject_magicEarWithReply_reportsError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@reply a b][@reply or @question should not be used for a magic ear]" + //
            "", validate(Archetype.TYPE_MAGIC_EAR, "@match a\n" + "@reply a b", creator));
    }
 
    @Test
    public void validateGameObject_magicEarWithQuestion_reportsError() {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        Assert.assertEquals("" + //
            "SuspiciousMsgSyntaxError[@question a b][@reply or @question should not be used for a magic ear]" + //
            "", validate(Archetype.TYPE_MAGIC_EAR, "@match a\n" + "@question a b", creator));
    }
 
    @Test
    public void validateGameObject_replyNotMatched1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@reply b b][keyword 'b' in '@reply' does not appear in any @match line]" + //
            "", validate("@match a\n" + "1\n" + "@reply b b"));
    }
 
    @Test
    public void validateGameObject_replyNotMatched2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[1][keyword 'b' in '@reply' does not appear in any @match line]" + //
            "", validate("@match a\n" + "1\n" + "@reply b b\n" + "@match *\n" + "1"));
    }
 
    @Test
    public void validateGameObject_questionNotMatched1_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[@question b b][keyword 'b' in '@question' does not appear in any @match line]" + //
            "", validate("@match a\n" + "1\n" + "@question b b"));
    }
 
    @Test
    public void validateGameObject_questionNotMatched2_reportsError() {
        Assert.assertEquals("" + //
            "SuspiciousMsgKeywordError[1][keyword 'b' in '@question' does not appear in any @match line]" + //
            "", validate("@match a\n" + "1\n" + "@question b b\n" + "@match *\n" + "1"));
    }
 
    @Test
    public void validateGameObject_allowMatchNoteAfterMatchAll_reportsError() {
        Assert.assertNull(validate("@match *\n" + "1\n" + "@match note\n" + "1")); // allow this: some maps use this for notes to developers
    }
 
    @Nullable
    private static String validate(@Nullable final String msg) {
        final TestMapModelCreator creator = new TestMapModelCreator(false);
        return validate(0, msg, creator);
    }
 
    @Nullable
    private static String validate(final int type, @Nullable final String msg, final TestMapModelCreator creator) {
        final GameObjectValidator<TestGameObject, TestMapArchObject, TestArchetype> checker = new SuspiciousMsgChecker<>(new TestValidatorPreferences());
        final ErrorCollector<TestGameObject, TestMapArchObject, TestArchetype> errorCollector = new DefaultErrorCollector<>();
        final TestGameObject mapGameObject = newGameObject(type, msg, creator);
        checker.validateGameObject(mapGameObject, errorCollector);
        final StringBuilder sb = new StringBuilder();
        for (final ValidationError<TestGameObject, TestMapArchObject, TestArchetype> error : errorCollector.getErrors()) {
            sb.append(error.getClass().getSimpleName()).append("[").append(error.getParameter(0)).append("][").append(error.getParameter(1)).append("]");
        }
        return sb.length() == 0 ? null : sb.toString();
    }
 
    @NotNull
    private static TestGameObject newGameObject(final int type, @Nullable final String msg, @NotNull final TestMapModelCreator creator) {
        final MapModel<TestGameObject, TestMapArchObject, TestArchetype> map = creator.newMapModel(1, 1);
        final TestGameObject gameObject = creator.newGameObject("test", "name", type);
        gameObject.setMsgText(msg);
        map.beginTransaction("test");
        try {
            map.insertBaseObject(gameObject, new Point(0, 0), true, false, creator.getTopmostInsertionMode());
        } finally {
            map.endTransaction();
        }
        final TestGameObject mapGameObject = map.getMapSquare(new Point(0, 0)).getFirst();
        Assert.assertNotNull(mapGameObject);
        return mapGameObject;
    }
 
}