test_xpParse.pas
上传用户:yjb1804
上传日期:2021-01-30
资源大小:3105k
文件大小:13k
源码类别:

Email服务器

开发平台:

Delphi

  1. unit TEST_xpParse;
  2. (*
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  *
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  *
  13.  * This code was inspired to expidite the creation of unit tests 
  14.  * for use the Dunit test frame work.
  15.  * 
  16.  * The Initial Developer of XPGen is Michael A. Johnson.
  17.  * Portions created The Initial Developer is Copyright (C) 2000.
  18.  * Portions created by The DUnit Group are Copyright (C) 2000.
  19.  * All rights reserved.
  20.  *
  21.  * Contributor(s):
  22.  * Michael A. Johnson <majohnson@golden.net>
  23.  * Juanco A馿z <juanco@users.sourceforge.net>
  24.  * Chris Morris <chrismo@users.sourceforge.net>
  25.  * Jeff Moore <JeffMoore@users.sourceforge.net>
  26.  * The DUnit group at SourceForge <http://dunit.sourceforge.net>
  27.  *
  28.  *)
  29. interface
  30. uses
  31.   classes,
  32.   TestFramework,
  33.   parseDef,
  34.   xpParse,
  35.   SysUtils;
  36. type
  37.   TParseNodeParams = record
  38.    NameOfClass : string;
  39.    NumPublicMethods,
  40.    NumProtectedMethods,
  41.    NumPrivateMethods  : integer;
  42.   end;
  43.   
  44.   MockTParseNodeClass = class(TParseNodeClass);
  45.   MockTXPStubParser = class(TXPStubParser);
  46.   TEST_TParseNodeClass = class(TTestCase)
  47.   public
  48.     procedure setUp; override;
  49.     procedure tearDown; override;
  50.   end;
  51.   TEST_TXPStubParser = class(TTestCase)
  52.   protected
  53.     testInstance: MockTXPStubParser;
  54.     procedure SetupParse(parser: MockTXPStubParser; filename: TFilename);
  55.     procedure TeardownParse(parser: MockTXPStubParser);
  56.     function HasExpectedParseNodes(parseNodeList : TList;const NodeParams : array of TParseNodeParams) : boolean;
  57.   public
  58.     procedure setUp; override;
  59.     procedure tearDown; override;
  60.   published
  61.     procedure test_Get_Token;
  62.     procedure test_Parse_Unit_Heading;
  63.     procedure test_Parse_const_Paragraph;
  64.     procedure test_Parse_type_Paragraph;
  65.     procedure test_Parse_var_paragraph;
  66.     procedure test_Parse_uses_clause;
  67.     procedure test_Parse_typedef;
  68.     procedure test_Parse_tobject_derived;
  69.     procedure test_Parse_derived;
  70.     procedure test_SyncToken;
  71.     procedure test_ParseEventDef;
  72.   end;
  73. function Suite: ITestSuite;
  74. implementation
  75. uses
  76.   xpLex,
  77.   dialogs;
  78. function Suite: ITestSuite;
  79. begin
  80.   result := TTestSuite.create('xpGen xpParse tests');
  81. end;
  82. procedure TEST_TParseNodeClass.setUp;
  83. begin
  84. end;
  85. procedure TEST_TParseNodeClass.tearDown;
  86. begin
  87. end;
  88. procedure TEST_TXPStubParser.setUp;
  89. begin
  90.   testInstance := MockTXPStubParser.Create;
  91. end;
  92. procedure TEST_TXPStubParser.tearDown;
  93. begin
  94.   testInstance.free;
  95. end;
  96. procedure TEST_TXPStubParser.TEST_Get_Token;
  97. const
  98.   { list of tokens expected from the the test file }
  99.   ExpectedToken: array[1..20] of string =
  100.     (
  101.     'unit', 'TEST_xpParse', ';', '(',
  102.     ')', '[', ']', ':', '=', '*', '/', '+', 'interface',
  103.     'uses', 'DUnit', ',', 'xpParse', ',', 'SysUtils', ';'
  104.     );
  105. var
  106.   iter: integer;
  107.   token: lex_token;
  108. begin
  109.   SetupParse(testInstance, 'TEST_Get_Token.txt');
  110.   try
  111.     for iter := low(ExpectedToken) to High(ExpectedToken) do
  112.       begin
  113.         token := testInstance.Get_Token(testInstance.Lex);
  114.         check(ExpectedToken[iter] = token.Str, 'Unexpected Parse Token');
  115.       end;
  116.   finally
  117.     TearDownParse(testInstance);
  118.   end;
  119. end;
  120. procedure TEST_TXPStubParser.TEST_Parse_Unit_Heading;
  121. const
  122.  ExpectedEnum = kw_semi;
  123.  ExpectedToken = ';';
  124. var
  125.   token: lex_token;
  126. begin
  127.   SetupParse(testInstance, 'TEST_Parse_Unit_Heading.txt');
  128.   try
  129.     token := testInstance.Get_Token(testInstance.lex);
  130.     check(token.token_type = kw_unit,'Expected Keyword Unit');
  131.     token := testInstance.Parse_Unit_Heading(testInstance.lex);    
  132.     check(expectedToken=token.Str, 'Unexpected parse token');
  133.   finally
  134.     TearDownParse(testInstance);
  135.   end;
  136. end;
  137. procedure TEST_TXPStubParser.TEST_Parse_const_Paragraph;
  138. const
  139.  ExpectedEnum = kw_type;
  140.  ExpectedToken = 'type';
  141. var
  142.   token: lex_token;
  143. begin
  144.   SetupParse(testInstance, 'TEST_Parse_const_Paragraph.txt');
  145.   try
  146.     token := testInstance.Get_Token(testInstance.lex);
  147.     Check(token.token_type = kw_const,'Expected Keyword const');
  148.     token := testInstance.Parse_const_paragraph(testInstance.lex);    
  149.     check(expectedToken = token.Str, 'Unexpected parse token');
  150.   finally
  151.     TearDownParse(testInstance);
  152.   end;
  153. end;
  154. procedure TEST_TXPStubParser.TEST_Parse_type_Paragraph;
  155. const
  156.  ExpectedEnum = kw_var;
  157.  ExpectedToken = 'var';
  158. const
  159.   ExpectedParseNodes : array[1..4] of TParseNodeParams =
  160.   (
  161.    (NameOfClass: 'EUnitIDExpected'; NumPublicMethods: 0; NumProtectedMethods: 0;NumPrivateMethods: 0),
  162.    (NameOfClass: 'EEqualExpected'; NumPublicMethods: 0;  NumProtectedMethods: 0;NumPrivateMethods: 0),
  163.    (NameOfClass: 'TParseNodeClass'; NumPublicMethods: 1;  NumProtectedMethods: 0;NumPrivateMethods: 0),
  164.    (NameOfClass: 'TXPStubParser'; NumPublicMethods: 1;  NumProtectedMethods: 15;NumPrivateMethods: 0)         
  165.   );
  166. var
  167.   token: lex_token;
  168. begin
  169.     SetupParse(testInstance, 'TEST_Parse_type_Paragraph.txt');
  170.   try
  171.     check(0=testInstance.fParseNodeList.count,'Unexpected Parse node count');
  172.     
  173.     token := testInstance.Get_Token(testInstance.lex);
  174.     assert(kw_type = token.token_type,'Expected KW Type');
  175.    
  176.     token := testInstance.Parse_type_Paragraph(testInstance.lex);
  177.     check(expectedToken= token.Str, 'Unexpected parse token');
  178.     HasExpectedParseNodes(testInstance.fparseNodeList,ExpectedParseNodes);
  179.     
  180.   finally
  181.     TearDownParse(testInstance);
  182.   end;
  183. end;
  184. procedure TEST_TXPStubParser.TEST_Parse_var_paragraph;
  185. const
  186.  ExpectedEnum = kw_semi;
  187.  ExpectedToken = ';';
  188. var
  189.   token: lex_token;
  190. begin
  191.   SetupParse(testInstance, 'TEST_Parse_var_paragraph.txt');
  192.   try
  193.     token := testInstance.Get_Token(testInstance.lex);
  194.     assert(token.token_type = kw_var,'Expected Keyword Unit');
  195.     token := testInstance.Parse_Unit_Heading(testInstance.lex);    
  196.     check(expectedToken= token.Str, 'Unexpected parse token');
  197.   finally
  198.     TearDownParse(testInstance);
  199.   end;
  200. end;
  201. procedure TEST_TXPStubParser.TEST_Parse_uses_clause;
  202. const
  203.  ExpectedEnum = kw_semi;
  204.  ExpectedToken = ';';
  205. var
  206.   token: lex_token;
  207. begin
  208.   SetupParse(testInstance, 'TEST_Parse_uses_clause.txt');
  209.   try
  210.     token := testInstance.Get_Token(testInstance.lex);
  211.     assert(token.token_type = kw_uses,'Expected Keyword Unit');
  212.     token := testInstance.Parse_Unit_Heading(testInstance.lex);    
  213.     check(expectedToken= token.Str, 'Unexpected parse token');
  214.   finally
  215.     TearDownParse(testInstance);
  216.   end;
  217. end;
  218. procedure TEST_TXPStubParser.TEST_Parse_typedef;
  219. const
  220.  ExpectedEnum = kw_end;
  221.  ExpectedToken = 'end';
  222. const
  223.   ExpectedParseNodes : array[1..1] of TParseNodeParams =
  224.   (
  225.    (NameOfClass: 'TXPStubParser'; NumPublicMethods: 1;  NumProtectedMethods: 15;NumPrivateMethods: 0)         
  226.   );
  227. var
  228.   token: lex_token;
  229. begin
  230.   SetupParse(testInstance, 'TEST_Parse_typedef.txt');
  231.   try
  232.   
  233.     check(0=testInstance.fParseNodeList.count,'Unexpected Parse node count');
  234.     
  235.     token := testInstance.Get_Token(testInstance.lex);
  236.     assert(kw_ident = token.token_type,'Expected identifier');
  237.    
  238.     token := testInstance.Parse_typedef(token.str,testInstance.lex);
  239.     check(expectedToken= token.Str, 'Unexpected parse token');
  240.     HasExpectedParseNodes(testInstance.fparseNodeList,ExpectedParseNodes);
  241.     
  242.   finally
  243.     TearDownParse(testInstance);
  244.   end;
  245. end;
  246. procedure TEST_TXPStubParser.TEST_Parse_tobject_derived;
  247. const
  248.  ExpectedEnum = kw_end;
  249.  ExpectedToken = 'end';
  250. var
  251.   token: lex_token;
  252.   parseNode : TParseNodeClass;
  253. begin
  254.   SetupParse(testInstance, 'TEST_Parse_tobject_derived.txt');
  255.   try
  256.     check(testInstance.fParseNodeList.count=0,'Unexpected Parse node count');
  257.     
  258.     testInstance.NewClassNode('foo');
  259.         
  260.     token := testInstance.Get_Token(testInstance.lex);
  261.     assert(token.token_type = kw_class,'Expected Keyword class');
  262.     token := testInstance.Parse_tobject_derived(token,testInstance.lex);
  263.     check(expectedToken= token.Str, 'Unexpected parse token');
  264.     check(testInstance.fParseNodeList.count=1,'Unexpected Parse node count');
  265.     parseNode := testInstance.fParseNodeList.first;
  266.     check(4=parseNode.fPubMethodList.count,'Unexepected number of public methods');
  267.     
  268.     check(3=parseNode.fPvtMethodList.count,'Unexepected number of private methods');    
  269.     
  270.     check(3=parseNode.fPrtMethodList.count,'Unexepected number of protected methods');        
  271.     
  272.   finally
  273.     TearDownParse(testInstance);
  274.   end;
  275. end;
  276. procedure TEST_TXPStubParser.TEST_Parse_derived;
  277. const
  278.  ExpectedEnum = kw_end;
  279.  ExpectedToken = 'end';
  280. var
  281.   token: lex_token;
  282.   parseNode : TParseNodeClass;
  283. begin
  284.   SetupParse(testInstance, 'TEST_Parse_derived.txt');
  285.   try
  286.     check(testInstance.fParseNodeList.count=0,'Unexpected Parse node count');
  287.     
  288.     testInstance.NewClassNode('foo');
  289.         
  290.     token := testInstance.Get_Token(testInstance.lex);
  291.     assert(kw_openParen = token.token_type,'Expected Identifier');
  292.    
  293.     token := testInstance.Parse_derived(token.str,testInstance.lex);
  294.     check(expectedToken= token.Str, 'Unexpected parse token');
  295.     check(testInstance.fParseNodeList.count=1,'Unexpected Parse node count');
  296.     parseNode := testInstance.fParseNodeList.first;
  297.     check(4=parseNode.fPubMethodList.count,'Unexepected number of public methods');
  298.     
  299.     check(3=parseNode.fPvtMethodList.count,'Unexepected number of private methods');    
  300.     
  301.     check(3=parseNode.fPrtMethodList.count,'Unexepected number of protected methods');        
  302.     
  303.   finally
  304.     TearDownParse(testInstance);
  305.   end;
  306. end;
  307. procedure TEST_TXPStubParser.TEST_SyncToken;
  308. const
  309.  ExpectedEnum = kw_semi;
  310.  ExpectedToken = ';';
  311. var
  312.   token: lex_token;
  313. begin
  314.   try
  315.     SetupParse(testInstance, 'TEST_Get_Token.txt');
  316.     token := testInstance.SyncToken(expectedEnum,testInstance.lex);
  317.     check(expectedToken= token.Str, 'Unexpected parse token');
  318.   finally
  319.     TearDownParse(testInstance);
  320.   end;
  321. end;
  322. procedure TEST_TXPStubParser.SetupParse(parser: MockTXPStubParser;
  323.   filename: TFilename);
  324. var
  325.   inputFile: TFileStream;
  326. begin
  327.   InputFile := TFileStream.Create(filename, fmOpenRead);
  328.   parser.SrcStream := InputFile;
  329.   parser.lex := TLexer.create(inputFile);
  330. end;
  331. procedure TEST_TXPStubParser.TeardownParse(
  332.   parser: MockTXPStubParser);
  333. begin
  334.   parser.lex.Free;
  335.   parser.SrcStream.Free;
  336.   parser.SrcStream := nil;
  337.   parser.lex := nil;
  338.   testInstance.EmptyParseNodeList;
  339. end;
  340. function TEST_TXPStubParser.HasExpectedParseNodes(parseNodeList: TList;
  341.   const NodeParams: array of TParseNodeParams): boolean;
  342. var
  343.   parseNode : TParseNodeClass;
  344.   nodeIter : integer;
  345. begin
  346.   check(high(NodeParams)-Low(NodeParams)+1=parseNodeList.count,'Unexpected number of nodes');
  347.   for nodeIter := low(NodeParams) to high(NodeParams) do
  348.     begin
  349.       ParseNode := ParseNodeList[nodeIter - low(NodeParams)];
  350.       check(NodeParams[nodeIter].NumPublicMethods=ParseNode.PubMethodList.count,'Unexpected number of public methods');
  351.       check(NodePArams[nodeIter].NumProtectedMethods=ParseNode.PrtMethodList.count,'Unexpected number of protected methods');
  352.       check(NodePArams[nodeIter].NumPrivateMethods=ParseNode.PvtMethodList.count,'Unexpected number of private methods');
  353.     end;
  354.   result := true;
  355. end;
  356. procedure TEST_TXPStubParser.test_ParseEventDef;
  357. var
  358.   token: lex_token;
  359. begin
  360.   SetupParse(testInstance, 'TEST_parseEventDef.txt');
  361.   try
  362.     token := TestInstance.SyncToken(kw_procedure,testInstance.lex);
  363.     Check(token.token_type = kw_procedure,'event type def not found');
  364.     token := TestInstance.ParseEventDef(token,testInstance.lex);
  365.     Check(token.token_type = kw_semi,'did not parse the simple event def');
  366.     token := TestInstance.SyncToken(kw_procedure,testInstance.lex);
  367.     Check(token.token_type = kw_procedure,'event type def not found');
  368.     token := TestInstance.ParseEventDef(token,testInstance.lex);
  369.     Check(token.token_type = kw_semi,'did not parse the complex event def');    
  370.     
  371.   finally
  372.     TearDownParse(testInstance);
  373.   end;
  374. end;
  375. initialization
  376.   TestFrameWork.RegisterTests('XPGEN parser tests',[
  377.                                        TEST_TXPStubParser.Suite,
  378.                                        TEST_TParseNodeClass.Suite
  379.                                        ]);
  380. end.