Changeset 2245


Ignore:
Timestamp:
Jan 12, 2007, 10:09:06 PM (14 years ago)
Author:
roman
Message:

Context checks

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

Legend:

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

    r2235 r2245  
    7171                assertFalse(e.isCompatibleWith("x", "b"));
    7272                assertTrue(e.isCompatibleWith("y", "a"));
    73                 assertTrue(e.isCompatibleWith("y", null));
    7473                LexicalEnvironment<String> e1 = new LexicalEnvironment<String>(e);
    75                 assertTrue(e1.isCompatibleWith("x", "b"));
    76                 assertTrue(e1.isCompatibleWith("x", null));
     74                assertFalse(e1.isCompatibleWith("x", "b"));
     75        }
     76
     77        @Test
     78        public void isCompatibleWithInScope() {
     79                e.bind("x", "a");
     80                assertTrue(e.isCompatibleWithInScope("x", "a"));
     81                assertFalse(e.isCompatibleWithInScope("x", "b"));
     82                assertTrue(e.isCompatibleWithInScope("y", "a"));
     83                LexicalEnvironment<String> e1 = new LexicalEnvironment<String>(e);
     84                assertTrue(e1.isCompatibleWithInScope("x", "b"));
     85        }
     86       
     87        @Test
     88        public void bindIfCompatible() {
     89                e.bind("x", "a");
     90                assertTrue(e.bindIfCompatible("x", "a"));
     91                assertFalse(e.bindIfCompatible("x", "b"));
     92                assertEquals("a", e.lookup("x"));
    7793        }
    7894}
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/ParserTest.java

    r2231 r2245  
    1313
    1414public class ParserTest {
    15 
    16         @BeforeClass
    17         public static void setUpBeforeClass() throws Exception {
    18         }
    19 
    20         @AfterClass
    21         public static void tearDownAfterClass() throws Exception {
    22         }
    2315
    2416        @Before
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/RfpStringParser.java

    r2239 r2245  
    1212
    1313public class RfpStringParser {
    14         public static AstInterf parseInterfString(String input) {
     14
     15        public static AstImplem parseImplemString(String input) {
     16                MsgHandler msgHandler = new ConsoleMsgHandler();
     17                return parseImplemString(input, msgHandler);
     18        }
     19
     20        public static AstImplem parseImplemString(String input,
     21                        MsgHandler msgHandler) {
    1522                StringReader stringReader = new StringReader(input);
    1623                PushbackReader reader = new PushbackReader(stringReader);
    17                 MsgHandler msgHandler = new ConsoleMsgHandler();
    1824                Scanner scanner = new Scanner(reader, "string", msgHandler);
    1925
    20                 AstInterf astInterf = Parser.parseInterf(scanner, "string",
    21                                 msgHandler);
     26                AstImplem astImplem = Parser.parseImplem(scanner, "string", msgHandler);
     27                return astImplem;
     28        }
     29
     30        public static AstInterf parseInterfString(String input) {
     31                MsgHandler msgHandler = new ConsoleMsgHandler();
     32                return parseInterfString(input, msgHandler);
     33        }
     34
     35        public static AstInterf parseInterfString(String input, MsgHandler msgHandler) {
     36                StringReader stringReader = new StringReader(input);
     37                PushbackReader reader = new PushbackReader(stringReader);
     38                Scanner scanner = new Scanner(reader, "string", msgHandler);
     39
     40                AstInterf astInterf = Parser.parseInterf(scanner, "string", msgHandler);
    2241                return astInterf;
    2342        }
    24 
    25         public static AstImplem parseImplemString(String input) {
    26                 StringReader stringReader = new StringReader(input);
    27                 PushbackReader reader = new PushbackReader(stringReader);
    28                 MsgHandler msgHandler = new ConsoleMsgHandler();
    29                 Scanner scanner = new Scanner(reader, "string", msgHandler);
    30 
    31                 AstImplem astImplem = Parser.parseImplem(scanner, "string",
    32                                 msgHandler);
    33                 return astImplem;
    34         }
    3543}
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/ScannerErrorTest.java

    r2243 r2245  
    2222        }
    2323
    24         private void scan(String input, MsgCode expected) {
     24        private static void scan(String input, MsgCode expected) {
    2525                MsgAccumulator msgAcc = new MsgAccumulator();
    2626                @SuppressWarnings("unused")
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/TestSuite.java

    r2243 r2245  
    1010                ScannerErrorTest.class, //
    1111                ParserTest.class, //
     12                LexicalEnvironmentTest.class, //
    1213                VariableScopeCheckerTest.class //
    1314})
  • devel-tools/trunk/eclipse/org.refal.plus.comp.test/src/org/refal/plus/comp/test/VariableScopeCheckerTest.java

    r2235 r2245  
    11package org.refal.plus.comp.test;
    22
    3 import static org.junit.Assert.*;
     3import static org.junit.Assert.assertEquals;
     4import static org.junit.Assert.assertTrue;
    45
    56import java.math.BigInteger;
     
    910import org.junit.Before;
    1011import org.junit.Test;
     12import org.refal.plus.comp.MsgCode;
    1113import org.refal.plus.comp.VariableCollector;
    1214import org.refal.plus.comp.TkAttributes.VarType;
     
    2224import org.refal.plus.comp.ast.AstWordSymbol;
    2325
     26import static org.refal.plus.comp.test.Util.*;
     27
    2428public class VariableScopeCheckerTest {
     29
     30        private static void checkNotDefined(String input, String expectedIndex) {
     31                expectMessage(input, MsgCode.Variable_X_IsNotDefined, expectedIndex);
     32        }
     33
     34        private static void checkDifferentTypes(String input, String expectedIndex) {
     35                expectMessage(input, MsgCode.TwoOccurrencesOfTheVariable_X_HaveDifferentTypes,
     36                                expectedIndex);
     37        }
    2538
    2639        @Before
     
    4760                AstExp astExp = new AstExp(new AstTerm[] { f_Call_sX, paren, ref,
    4861                                charSymbol, numberSymbol, wordSymbol });
    49                
     62
    5063                VariableCollector visitor = new VariableCollector();
    5164                astExp.accept(visitor);
    5265                ArrayList<AstVar> vs = visitor.variables;
    53                
     66
    5467                assertEquals(3, vs.size());
    5568                AstVar v1 = vs.get(0);
    5669                AstVar v2 = vs.get(1);
    5770                AstVar v3 = vs.get(2);
    58                
     71
    5972                assertTrue(v1.type == VarType.S && v1.index.equals("X"));
    6073                assertTrue(v2.type == VarType.S && v2.index.equals("Y"));
    6174                assertTrue(v3.type == VarType.E && v3.index.equals("X"));
    6275        }
     76
     77        @Test
     78        public void variableScope() {
     79                expectOK("F {};");
     80                expectOK("F {sX sX;};");
     81                checkDifferentTypes("F {sX tX;};", "X");
     82                checkDifferentTypes("F {sX, tX;};", "X");
     83                expectOK("F {sX, sX, sX;};");
     84
     85                checkNotDefined("F {sX, sY, sX;};", "Y");
     86                checkNotDefined("F {sX, sX, sY;};", "Y");
     87
     88                expectOK("F {eX, eX eX :: eY, eX eY;};");
     89                expectOK("F {eX, eX::eY, eY;};");
     90
     91                checkNotDefined("F {= sX;};", "X");
     92
     93                expectOK("F {eX = eX $iter eY eY :: eY, eX eY;};");
     94
     95                expectOK("F {(eX)(eY), eX : eY e1 = eX eY e1;};");
     96                checkDifferentTypes("F {(eX)(eY), eX : eY tX = eX eY;};", "X");
     97
     98                expectOK("F {eX, \\? \\! = $error eX;};");
     99                checkDifferentTypes("F {eX, tX\\? \\! = $error tX;};", "X");
     100
     101                expectOK("F {eX, #eX, eX;};");
     102                expectOK("F {eX $fail;};");
     103
     104                expectOK("F {eX $trap eX $with {eX, eX;};};");
     105                expectOK("F {eX , {eX;eX;};};");
     106                expectOK("F {eX , eX:{eX = eX;};};");
     107        }
     108
    63109}
Note: See TracChangeset for help on using the changeset viewer.