Changeset 2254


Ignore:
Timestamp:
Jan 18, 2007, 1:54:48 AM (14 years ago)
Author:
roman
Message:

Name checker

Location:
devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/EolTest.java

    r2208 r2254  
    1717
    1818public class EolTest {
    19 
    20         @BeforeClass
    21         public static void setUpBeforeClass() throws Exception {
    22         }
    23 
    24         @AfterClass
    25         public static void tearDownAfterClass() throws Exception {
    26         }
    2719
    2820        @Before
     
    4941               
    5042                String actual = sb.toString();
    51                 assertEquals(expected, actual);
     43                assertEquals("Lines are OK", expected, actual);
    5244                return;
    5345        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/FenceAndCutCheckerTest.java

    r2247 r2254  
    1919        private static void expectMessage(String input, MsgCode msgCode) {
    2020                MsgAccumulator msgAcc = parseAndReturnMessages(input);
    21                 assertTrue(msgAcc.messages.size() > 0);
    22                 assertEquals(msgCode, msgAcc.messages.get(0).msgCode);
     21                Util.checkMsg(msgAcc, msgCode);
    2322        }
    2423
     
    4948                expectOK("F = {\\? \\!;}, \\? \\!;");
    5049                expectOK("F = \\? A :: A, \\! X;");
    51                 expectOK("F = \\? A :: A, \\! X;");
    5250                expectOK("F = A $iter B :: C, D;");
    5351                expectOK("F = A : B , C;");
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/NameChekerTest.java

    r2251 r2254  
    11package org.refal.plus.comp.test;
    22
    3 
     3import static org.junit.Assert.assertEquals;
    44import static org.junit.Assert.assertTrue;
    55
     
    1010import org.refal.plus.comp.NameChecker;
    1111import org.refal.plus.comp.ast.AstImplem;
     12import org.refal.plus.comp.ast.ImageBuilder;
    1213
    1314public class NameChekerTest {
     
    2021        public void tearDown() throws Exception {
    2122        }
    22         private static void checkNotDefined(String input, String expectedIndex) {
    23                 expectMessage(input, MsgCode.Variable_X_IsNotDefined, expectedIndex);
    24         }
    2523
    26         private static void checkDifferentTypes(String input, String expectedIndex) {
    27                 expectMessage(input,
    28                                 MsgCode.TwoOccurrencesOfTheVariable_X_HaveDifferentTypes,
    29                                 expectedIndex);
     24        private static void implem(String input, String expected) {
     25                MsgAccumulator msgAcc = new MsgAccumulator();
     26                AstImplem astImplem = Util.parseImplemString(input, msgAcc);
     27                assertTrue("Syntax is OK", msgAcc.messages.isEmpty());
     28                NameChecker v = new NameChecker(msgAcc);
     29                v.visit(astImplem);
     30                assertTrue("Names are OK", msgAcc.messages.isEmpty());
     31                ImageBuilder imageBuilder = new ImageBuilder();
     32                astImplem.accept(imageBuilder);
     33                String actual = imageBuilder.toString();
     34                assertEquals("AST is OK", expected, actual);
    3035        }
    3136
     
    3338                MsgAccumulator msgAcc = new MsgAccumulator();
    3439                AstImplem astImplem = Util.parseImplemString(input, msgAcc);
    35                 NameChecker nc = new NameChecker(msgAcc);
    36                 nc.visit(astImplem);
     40                assertTrue("Syntax is OK", msgAcc.messages.isEmpty());
     41                NameChecker v = new NameChecker(msgAcc);
     42                v.visit(astImplem);
    3743                return msgAcc;
    3844        }
     
    5965        }
    6066       
     67        @Test
     68        public void errors() {
     69                expectMessage("$box F; F {};", MsgCode.X_IsNotAFunction, "F");
     70                expectMessage("$box F; $func F =;", MsgCode.DuplicateDeclarationOfTheName_X, "F");
     71                expectMessage("$box F; $string F;", MsgCode.DuplicateDeclarationOfTheName_X, "F");
     72                expectMessage("$box F; $const F =;", MsgCode.DuplicateDeclarationOfTheName_X, "F");
     73                expectMessage("F {};", MsgCode.Function_X_IsNotDeclared, "F");
     74                expectMessage("$func F =; $func F =;", MsgCode.DuplicateDeclarationOfTheName_X, "F");
     75                expectMessage("$func F =; F {}; F {};", MsgCode.DuplicateDefinitionOfTheFunction_X, "F");
     76                expectMessage("$const X = &F;", MsgCode.Name_X_IsNotDefined, "F");
     77                expectMessage("$func F =; F {&X;};", MsgCode.Name_X_IsNotDefined, "X");
     78        }
     79
     80        @Test
     81        public void expansion() {
     82                implem("$const A = X; $const B = &A &A;",
     83                                "$const A = X;$const B = X X;");
     84                implem("$const A = X Y (Z); $const B = &A (&A);",
     85                                "$const A = X Y (Z);$const B = X Y (Z) (X Y (Z));");
     86
     87                implem("$const A = X;$func F e = e;F{&A, &A::&A,&A;};",
     88                                "$const A = X;$func F e = e;F{X,X::X,X;};");
     89                implem("$const A = X;$func F = ;F{,&A $iter &A :: &A,;};",
     90                                "$const A = X;$func F  = ;F{,X $iter X::X,;};");
     91                implem("$const A = X;$func F e = e;F{,&A : &A,&A;};",
     92                                "$const A = X;$func F e = e;F{,X:X,X;};");
     93                implem("$const A = X;$func F e = e;F{,#&A,&A;};",
     94                                "$const A = X;$func F e = e;F{,#X,X;};");
     95                implem("$const A = X;$func F e = e;F{,\\?\\! = $error &A;};",
     96                                "$const A = X;$func F e = e;F{,\\?\\! = $error X;};");
     97                implem("$const A = X;$func F e = e;F{,$fail;};",
     98                                "$const A = X;$func F e = e;F{,$fail;};");
     99                implem("$const A = X;$func F e = e;F{,$trap &A $with {&A, &A;};};",
     100                                "$const A = X;$func F e = e;F{,$trap X $with {X,X;};};");
     101                implem("$const A = X;$func F e = e;F{,{&A;&A;};};",
     102                                "$const A = X;$func F e = e;F{,{X;X;};};");
     103                implem("$const A = X;$func F e = e;F{,&A:{&A, &A;};};",
     104                                "$const A = X;$func F e = e;F{,X:{X,X;};};");
     105        }
    61106}
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/ParserTest.java

    r2251 r2254  
    22
    33import static org.junit.Assert.assertEquals;
     4import static org.junit.Assert.assertTrue;
    45
    56import org.junit.After;
     
    2021        }
    2122
    22         public void interf(String input) {
    23                 AstInterf astInterf = Util.parseInterfString(input);
    24                 ImageBuilder imageBuilder = new ImageBuilder();
    25                 astInterf.accept(imageBuilder);
    26                 String image = imageBuilder.toString();
    27                 System.out.println(image);
    28                 return;
    29         }
    30 
    3123        public void interf(String input, String expected) {
    32                 AstInterf astInterf = Util.parseInterfString(input);
     24                MsgAccumulator msgAcc = new MsgAccumulator();
     25                AstInterf astInterf = Util.parseInterfString(input, msgAcc);
     26                assertTrue("Syntax is OK", msgAcc.messages.isEmpty());
    3327                ImageBuilder imageBuilder = new ImageBuilder();
    3428                astInterf.accept(imageBuilder);
    3529                String actual = imageBuilder.toString();
    36                 assertEquals(expected, actual);
    37                 return;
    38         }
    39 
    40         public void implem(String input) {
    41                 AstImplem astImplem = Util.parseImplemString(input);
    42                 ImageBuilder imageBuilder = new ImageBuilder();
    43                 astImplem.accept(imageBuilder);
    44                 String image = imageBuilder.toString();
    45                 System.out.println(image);
    46                 return;
     30                assertEquals("AST is OK", expected, actual);
    4731        }
    4832
    4933        public void implem(String input, String expected) {
    50                 AstImplem astImplem = Util.parseImplemString(input);
     34                MsgAccumulator msgAcc = new MsgAccumulator();
     35                AstImplem astImplem = Util.parseImplemString(input, msgAcc);
     36                assertTrue("Syntax is OK", msgAcc.messages.isEmpty());
    5137                ImageBuilder imageBuilder = new ImageBuilder();
    5238                astImplem.accept(imageBuilder);
    5339                String actual = imageBuilder.toString();
    54                 assertEquals(expected, actual);
    55                 return;
     40                assertEquals("AST is OK", expected, actual);
    5641        }
    5742
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/ScannerErrorTest.java

    r2251 r2254  
    11package org.refal.plus.comp.test;
    2 
    3 import static org.junit.Assert.assertEquals;
    4 import static org.junit.Assert.assertTrue;
    52
    63import java.io.IOException;
     
    2219        }
    2320
    24         private static void scan(String input, MsgCode expected) {
     21        private static void scan(String input, MsgCode msgCode) {
    2522                MsgAccumulator msgAcc = new MsgAccumulator();
    2623                @SuppressWarnings("unused")
    2724                Object[] actual = Util.scanString(input, msgAcc);
    28                 assertTrue(msgAcc.messages.size() > 0);
    29                 assertEquals(expected, msgAcc.messages.get(0).msgCode);
     25                Util.checkMsg(msgAcc, msgCode);
    3026        }
    3127
     
    6561                };
    6662                MsgAccumulator msgAcc = new MsgAccumulator();
    67 
    6863                @SuppressWarnings("unused")
    6964                Object[] actual = Util.scan(badReader, msgAcc);
    70                 assertTrue(msgAcc.messages.size() > 0);
    71                 MsgAccumulator.Message msg = msgAcc.messages.get(0);
    72                 assertEquals(MsgCode.IOExceptionThrown, msg.msgCode);
    73                 assertEquals(1, msg.args.length);
    74                 assertEquals("read failed", msg.args[0]);
     65                Util.checkMsg(msgAcc, MsgCode.IOExceptionThrown, "read failed");
    7566        }
    7667}
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/ScannerTest.java

    r2251 r2254  
    22
    33import static org.junit.Assert.assertEquals;
    4 import static org.refal.plus.comp.TkTags.*;
    5 import static org.refal.plus.comp.TkAttributes.*;
    6 import static org.refal.plus.comp.test.Token.*;
     4import static org.refal.plus.comp.TkTags.COL;
     5import static org.refal.plus.comp.TkTags.COL_CURL;
     6import static org.refal.plus.comp.TkTags.COMMA;
     7import static org.refal.plus.comp.TkTags.CONST;
     8import static org.refal.plus.comp.TkTags.CUT;
     9import static org.refal.plus.comp.TkTags.EQL;
     10import static org.refal.plus.comp.TkTags.ERROR;
     11import static org.refal.plus.comp.TkTags.FAIL;
     12import static org.refal.plus.comp.TkTags.FENCE;
     13import static org.refal.plus.comp.TkTags.FUNC_DECL;
     14import static org.refal.plus.comp.TkTags.ITER;
     15import static org.refal.plus.comp.TkTags.LANGU;
     16import static org.refal.plus.comp.TkTags.LCURL;
     17import static org.refal.plus.comp.TkTags.LET;
     18import static org.refal.plus.comp.TkTags.LPAR;
     19import static org.refal.plus.comp.TkTags.MATCH_DIR;
     20import static org.refal.plus.comp.TkTags.NOT;
     21import static org.refal.plus.comp.TkTags.OBJ_DECL;
     22import static org.refal.plus.comp.TkTags.RANGU;
     23import static org.refal.plus.comp.TkTags.RCURL;
     24import static org.refal.plus.comp.TkTags.REF;
     25import static org.refal.plus.comp.TkTags.RPAR;
     26import static org.refal.plus.comp.TkTags.SC;
     27import static org.refal.plus.comp.TkTags.TRACE_ALL;
     28import static org.refal.plus.comp.TkTags.TRAP;
     29import static org.refal.plus.comp.TkTags.USE;
     30import static org.refal.plus.comp.TkTags.WITH;
     31import static org.refal.plus.comp.test.Token.kw;
     32import static org.refal.plus.comp.test.Token.tChar;
     33import static org.refal.plus.comp.test.Token.tIdent;
     34import static org.refal.plus.comp.test.Token.tInt;
     35import static org.refal.plus.comp.test.Token.tVar;
     36import static org.refal.plus.comp.test.Token.tWord;
    737
    838import org.junit.After;
    9 import org.junit.AfterClass;
    1039import org.junit.Before;
    11 import org.junit.BeforeClass;
    1240import org.junit.Test;
     41import org.refal.plus.comp.TkAttributes.MatchDir;
     42import org.refal.plus.comp.TkAttributes.ObjKind;
     43import org.refal.plus.comp.TkAttributes.RetMode;
    1344
    1445public class ScannerTest {
    15 
    16         @BeforeClass
    17         public static void setUpBeforeClass() throws Exception {
    18         }
    19 
    20         @AfterClass
    21         public static void tearDownAfterClass() throws Exception {
    22         }
    2346
    2447        @Before
     
    3255        private void scan(String input, Object[] expected) {
    3356                Object[] actual = Util.scanString(input);
    34                 assertEquals(expected, actual);
     57                assertEquals("Tokens are OK", expected, actual);
    3558        }
    3659
     
    141164                        int[] expectedCharEnds) {
    142165                Object[] actual = Util.scanString(input);
    143                 assertEquals(expected, actual);
     166                assertEquals("Tokens are OK", expected, actual);
    144167                for (int i = 0; i < actual.length; i++) {
    145168                        Token t = (Token) actual[i];
    146                         assertEquals(expectedLines[i], t.pos.line);
    147                         assertEquals(expectedCharStarts[i], t.pos.charStart);
    148                         assertEquals(expectedCharEnds[i], t.pos.charEnd);
     169                        assertEquals("Line number is OK", expectedLines[i], t.pos.line);
     170                        assertEquals("CharStart is OK", expectedCharStarts[i], t.pos.charStart);
     171                        assertEquals("CharEnd is OK", expectedCharEnds[i], t.pos.charEnd);
    149172                }
    150173        }
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/Util.java

    r2251 r2254  
    2626                        MsgAccumulator msgAcc) {
    2727                AstImplem astImplem = Util.parseImplemString(input, msgAcc);
    28                 assertTrue(msgAcc.messages.size() == 0);
    29                 assertTrue(astImplem.topNodes.length == 1);
     28                assertTrue("Syntax is OK", msgAcc.messages.isEmpty());
     29                assertTrue("Single top node", astImplem.topNodes.length == 1);
    3030                AstTopNode astTopNode = astImplem.topNodes[0];
    31                 assertTrue(astTopNode instanceof AstFuncDef);
     31                assertTrue("Top node is AstFuncDef", astTopNode instanceof AstFuncDef);
    3232                return (AstFuncDef) astImplem.topNodes[0];
    3333        }
    3434
    35         static void checkMsg(MsgAccumulator msgAcc, MsgCode msgCode, String expectedArg) {
    36                 assertTrue(msgAcc.messages.size() > 0);
     35        public static void checkMsg(MsgAccumulator msgAcc, MsgCode msgCode) {
     36                assertTrue("There is a message", msgAcc.messages.size() > 0);
    3737                Message msg = msgAcc.messages.get(0);
    38                 assertEquals(msgCode, msg.msgCode);
     38                assertEquals("Message code is OK", msgCode, msg.msgCode);
     39        }
     40
     41        public static void checkMsg(MsgAccumulator msgAcc, MsgCode msgCode, String expectedArg) {
     42                assertTrue("There is a message", msgAcc.messages.size() > 0);
     43                Message msg = msgAcc.messages.get(0);
     44                assertEquals("Message code is OK", msgCode, msg.msgCode);
    3945                assertTrue(msg.args.length > 0);
    40                 assertEquals(expectedArg, msg.args[0]);
     46                assertEquals("The message has an argument", expectedArg, msg.args[0]);
    4147        }
    4248
     
    4652                PushbackReader reader = new PushbackReader(stringReader);
    4753                Scanner scanner = new Scanner(reader, "string", msgHandler);
    48        
    49                 AstImplem astImplem = Parser.parseImplem(scanner, "string", msgHandler);
    50                 return astImplem;
    51         }
    52 
    53         public static AstImplem parseImplemString(String input) {
    54                 MsgHandler msgHandler = new ConsoleMsgHandler();
    55                 return parseImplemString(input, msgHandler);
     54                return Parser.parseImplem(scanner, "string", msgHandler);
    5655        }
    5756
     
    6059                PushbackReader reader = new PushbackReader(stringReader);
    6160                Scanner scanner = new Scanner(reader, "string", msgHandler);
    62        
    63                 AstInterf astInterf = Parser.parseInterf(scanner, "string", msgHandler);
    64                 return astInterf;
     61                return Parser.parseInterf(scanner, "string", msgHandler);
    6562        }
    6663
     
    7370                ArrayList<Token> tokens = new ArrayList<Token>();
    7471                PushbackReader pushbackReader = new PushbackReader(reader);
    75                 Scanner scanner = new Scanner(pushbackReader, "ERROR", msgHandler);
     72                Scanner scanner = new Scanner(pushbackReader, "string", msgHandler);
    7673                for (;;) {
    7774                        scanner.getNextToken();
Note: See TracChangeset for help on using the changeset viewer.