/packages/fcl-db/tests/tcsqlscanner.pas

https://github.com/slibre/freepascal · Pascal · 1626 lines · 1306 code · 289 blank · 31 comment · 0 complexity · af1666554f13cc7e2efc09060c99512f MD5 · raw file

  1. {
  2. This file is part of the Free Component Library
  3. Copyright (c) 2010 by the Free Pascal development team
  4. SQL source lexical scanner test suite
  5. See the file COPYING.FPC, included in this distribution,
  6. for details about the copyright.
  7. This program is distributed in the hope that it will be useful,
  8. but WITHOUT ANY WARRANTY; without even the implied warranty of
  9. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10. **********************************************************************}
  11. unit tcsqlscanner;
  12. {$mode objfpc}{$H+}
  13. interface
  14. uses
  15. Classes, SysUtils, fpcunit, testutils, testregistry, fpsqlscanner;
  16. type
  17. { TTestSQLScanner }
  18. TTestSQLScanner= class(TTestCase)
  19. Private
  20. FStream : TStream;
  21. FLineReader : TLineReader;
  22. FScanner : TSQLScanner;
  23. FErrorSource : String;
  24. FErrorOptions : TSQLScannerOptions;
  25. procedure AssertEquals(AMessage: String; AExpected, AActual : TSQLToken); overload;
  26. procedure CheckToken(AToken: TSQLToken; ASource: String);
  27. procedure CheckTokens(ASource: String; ATokens: array of TSQLToken);
  28. procedure DoTestFloat(F: Double);
  29. procedure DoTestFloat(F: Double; S: String);
  30. procedure DoTestString(S: String; DoubleDelim : Boolean = False);
  31. procedure TestErrorSource;
  32. protected
  33. Function CreateScanner(AInput : String; AOptions : TSQLScannerOptions = []) : TSQLScanner;
  34. procedure FreeScanner;
  35. procedure SetUp; override;
  36. procedure TearDown; override;
  37. Property Scanner : TSQLScanner Read FScanner;
  38. published
  39. procedure TestAction;
  40. procedure TestAdd;
  41. procedure TestAdmin;
  42. procedure TestAfter;
  43. procedure TestALTER;
  44. procedure TestAnd;
  45. procedure TestAny;
  46. procedure TestAs;
  47. procedure TestASC;
  48. procedure TestASCENDING;
  49. Procedure TestAt;
  50. procedure TestAuto;
  51. procedure TestAVG;
  52. procedure TestAssign;
  53. procedure TestBefore;
  54. Procedure TestBegin;
  55. procedure TestBetween;
  56. procedure TestBlob;
  57. procedure TestBraceClose;
  58. procedure TestBraceOpen;
  59. procedure TestBy;
  60. Procedure TestCache;
  61. procedure TestCascade;
  62. procedure TestChar;
  63. procedure TestCharacter;
  64. procedure TestCheck;
  65. procedure TestCollate;
  66. procedure TestColon;
  67. procedure TestColumn;
  68. procedure TestComma;
  69. procedure TestCommit;
  70. procedure TestComputed;
  71. procedure TestConcatenate;
  72. Procedure TestConditional;
  73. Procedure TestConnect;
  74. procedure TestConstraint;
  75. procedure TestContaining;
  76. procedure TestCount;
  77. procedure TestCreate;
  78. procedure TestCString;
  79. Procedure TestDatabase;
  80. Procedure TestDate;
  81. Procedure TestDecimal;
  82. procedure TestDeclare;
  83. procedure TestDefault;
  84. procedure TestDelete;
  85. procedure TestDesc;
  86. procedure TestDescending;
  87. procedure TestDistinct;
  88. procedure TestDiv;
  89. procedure TestDO;
  90. procedure TestDomain;
  91. procedure TestDot;
  92. procedure TestDrop;
  93. procedure TestElse;
  94. procedure TestEmpty;
  95. procedure TestEnd;
  96. Procedure TestEntryPoint;
  97. procedure TestEq;
  98. procedure TestEscape;
  99. procedure TestException;
  100. procedure TestExists;
  101. procedure TestExit;
  102. Procedure TestExternal;
  103. Procedure TestExtract;
  104. procedure TestFile;
  105. Procedure TestFloat;
  106. procedure TestFor;
  107. procedure TestForeign;
  108. procedure TestFreeIt;
  109. procedure TestFunction;
  110. Procedure TestGDSError;
  111. procedure TestGE;
  112. procedure TestGenerator;
  113. procedure TestGrant;
  114. procedure TestGreaterThan;
  115. procedure TestGroup;
  116. Procedure TestHaving;
  117. procedure TestIf;
  118. procedure TestIn;
  119. procedure TestIndex;
  120. procedure TestInner;
  121. procedure TestInsert;
  122. procedure TestInt;
  123. procedure TestInteger;
  124. procedure TestInto;
  125. procedure TestIs;
  126. procedure TestJoin;
  127. procedure TestKey;
  128. procedure TestLeft;
  129. Procedure TestLength;
  130. procedure TestLike;
  131. procedure TestLE;
  132. procedure TestLessThan;
  133. Procedure TestManual;
  134. Procedure TestModuleName;
  135. procedure TestMax;
  136. procedure TestMerge;
  137. procedure TestMin;
  138. procedure TestMinus;
  139. procedure TestMul;
  140. procedure TestNational;
  141. procedure TestNatural;
  142. procedure TestNE;
  143. procedure TestNo;
  144. procedure TestNot;
  145. procedure TestNull;
  146. procedure TestNumeric;
  147. Procedure TestOn;
  148. Procedure TestOption;
  149. Procedure TestOr;
  150. Procedure TestOrder;
  151. Procedure TestOuter;
  152. Procedure TestPage;
  153. Procedure TestPages;
  154. Procedure TestPageSize;
  155. Procedure TestPassword;
  156. procedure TestPlus;
  157. procedure TestPosition;
  158. Procedure TestPostEvent;
  159. procedure TestPrimary;
  160. procedure TestPrivileges;
  161. procedure TestProcedure;
  162. procedure TestPublic;
  163. Procedure TestReferences;
  164. Procedure TestRelease;
  165. Procedure TestReturningValues;
  166. Procedure TestReturns;
  167. Procedure TestRetain;
  168. Procedure TestRevoke;
  169. Procedure TestRight;
  170. Procedure TestRole;
  171. Procedure TestRollback;
  172. Procedure TestSegment;
  173. Procedure TestSelect;
  174. procedure TestSemicolon;
  175. Procedure TestSet;
  176. Procedure TestSchema;
  177. Procedure TestShadow;
  178. Procedure TestSingular;
  179. Procedure TestSize;
  180. Procedure TestSkip;
  181. Procedure TestSome;
  182. Procedure TestSort;
  183. Procedure TestSnapshot;
  184. Procedure TestSQLCode;
  185. procedure TestSquareBraceClose;
  186. procedure TestSquareBraceOpen;
  187. Procedure TestStarting;
  188. procedure TestString;
  189. procedure TestSubtype;
  190. Procedure TestSum;
  191. Procedure TestSuspend;
  192. Procedure TestTable;
  193. Procedure TestThen;
  194. Procedure TestTime;
  195. Procedure TestTimeStamp;
  196. Procedure TestTo;
  197. Procedure TestTransaction;
  198. Procedure TestTrigger;
  199. Procedure TestType;
  200. Procedure TestUnion;
  201. Procedure TestUnique;
  202. Procedure TestUpdate;
  203. Procedure TestUpper;
  204. Procedure TestUser;
  205. procedure TestValue;
  206. procedure TestValues;
  207. procedure TestVariable;
  208. procedure TestVarChar;
  209. Procedure TestVarying;
  210. Procedure TestView;
  211. Procedure TestWhen;
  212. Procedure TestWhere;
  213. procedure TestWhile;
  214. procedure TestWith;
  215. procedure TestWork;
  216. Procedure Test2Words;
  217. procedure Test3Words;
  218. procedure TestIdentifier;
  219. procedure TestIdentifier2;
  220. procedure TestIdentifier3;
  221. procedure TestIdentifier4;
  222. procedure TestIdentifier5;
  223. procedure TestIdentifierDotIdentifier;
  224. procedure TestEOLN;
  225. procedure TestEOLN2;
  226. procedure TestEOLN3;
  227. procedure TestEOLN4;
  228. procedure TestComment1;
  229. procedure TestComment2;
  230. procedure TestComment3;
  231. procedure TestComment4;
  232. procedure TestComment5;
  233. procedure TestComment6;
  234. procedure TestFloatLiteral;
  235. procedure TestStringLiteral1;
  236. procedure TestStringLiteral2;
  237. procedure TestStringError;
  238. procedure TestFloatError;
  239. Procedure TestOptionsoDoubleQuoteStringLiteral;
  240. Procedure TestOptionsoSingleQuoteIdentifier;
  241. procedure TestOptionsoBackQuoteIdentifier;
  242. procedure TestOptionNosoBackQuoteIdentifier;
  243. procedure TestOptionNosoBackslashEscapes;
  244. procedure TestOptionsoBackslashEscapesTab;
  245. procedure TestOptionsoBackslashEscapesNewLine;
  246. procedure TestOptionsoBackslashEscapesBackSlash;
  247. procedure TestOptionsoBackslashEscapesBackspace;
  248. procedure TestOptionsoBackslashEscapesLineFeed;
  249. procedure TestOptionsoBackslashEscapesNewPage;
  250. procedure TestOptionsoBackslashEscapesSlash;
  251. procedure TestOptionsoBackslashEscapesQuote;
  252. procedure TestOptionsoBackslashEscapesDoubleQuote;
  253. end;
  254. implementation
  255. uses typinfo;
  256. procedure TTestSQLScanner.AssertEquals(AMessage: String; AExpected,
  257. AActual: TSQLToken);
  258. Var
  259. S,EN1,EN2 : String;
  260. begin
  261. If (AActual<>AExpected) then
  262. begin
  263. EN1:=GetEnumName(TypeINfo(TSQLToken),Ord(AExpected));
  264. EN2:=GetEnumName(TypeINfo(TSQLToken),Ord(AActual));
  265. S:=Format('%s : %s <> %s',[AMessage,EN1,EN2]);
  266. Fail(S);
  267. end;
  268. end;
  269. procedure TTestSQLScanner.CheckToken(AToken: TSQLToken; ASource: String);
  270. Var
  271. J : TSqlToken;
  272. EN2 : String;
  273. begin
  274. CreateScanner(ASource);
  275. J:=Scanner.FetchToken;
  276. EN2:=GetEnumName(TypeINfo(TSQLToken),Ord(AToken));
  277. AssertEquals(Format('Source %s should result in %s.',[ASource,EN2]),AToken,J);
  278. end;
  279. procedure TTestSQLScanner.DoTestFloat(F: Double);
  280. Var
  281. S : String;
  282. begin
  283. Str(F,S);
  284. DoTestFloat(F,S);
  285. end;
  286. procedure TTestSQLScanner.DoTestFloat(F: Double; S: String);
  287. Var
  288. J : TSQLToken;
  289. C : Double;
  290. I : integer;
  291. V : String;
  292. begin
  293. CreateScanner(S);
  294. try
  295. J:=FScanner.FetchToken;
  296. AssertEquals(S+' is a number',tsqlFloatNumber,J);
  297. V:=FScanner.CurTokenString;
  298. Val(V,C,I);
  299. If (I<>0) then
  300. Fail(FScanner.CurTokenString+' does not contain a float value');
  301. AssertEquals('Parsed float equals original float',F,C);
  302. finally
  303. FreeScanner;
  304. end;
  305. end;
  306. procedure TTestSQLScanner.DoTestString(S: String; DoubleDelim : Boolean = False);
  307. Var
  308. J : TSQLToken;
  309. C : Char;
  310. begin
  311. CreateScanner(S);
  312. try
  313. J:=FScanner.FetchToken;
  314. AssertEquals(S+' is a string',tsqlString,J);
  315. If (Length(S)>0) and (S[1] in ['"','''']) then
  316. begin
  317. C:=S[1];
  318. S:=Copy(S,2,Length(S)-2);
  319. end;
  320. If DoubleDelim then
  321. S:=StringReplace(S,C+C,C,[rfReplaceAll]);
  322. AssertEquals('Correct string is returned',S,FScanner.CurTokenString);
  323. finally
  324. FreeScanner;
  325. end;
  326. end;
  327. procedure TTestSQLScanner.TestErrorSource;
  328. begin
  329. CreateScanner(FErrorSource,FErrorOptions);
  330. While (FScanner.FetchToken<>tsqlEOF) do ;
  331. end;
  332. function TTestSQLScanner.CreateScanner(AInput: String; AOptions : TSQLScannerOptions = []): TSQLScanner;
  333. begin
  334. FStream:=TStringStream.Create(AInput);
  335. FLineReader:=TStreamLineReader.Create(Fstream);
  336. FScanner:=TSQLScanner.Create(FLineReader);
  337. FScanner.Options:=AOptions;
  338. Result:=FSCanner;
  339. end;
  340. procedure TTestSQLScanner.FreeScanner;
  341. begin
  342. FreeAndNil(FScanner);
  343. FreeAndNil(FLineReader);
  344. FreeAndNil(FStream);
  345. end;
  346. procedure TTestSQLScanner.SetUp;
  347. begin
  348. inherited SetUp;
  349. FErrorSource:='';
  350. FErrorOptions:=[];
  351. end;
  352. procedure TTestSQLScanner.TearDown;
  353. begin
  354. FreeScanner;
  355. iNHERITED;
  356. end;
  357. procedure TTestSQLScanner.TestAction;
  358. begin
  359. CheckToken(tsqlAction,'ACTION');
  360. end;
  361. procedure TTestSQLScanner.TestAdd;
  362. begin
  363. CheckToken(tsqlAdd,'ADD');
  364. end;
  365. procedure TTestSQLScanner.TestAdmin;
  366. begin
  367. CheckToken(tsqlAdmin,'ADMIN');
  368. end;
  369. procedure TTestSQLScanner.TestAfter;
  370. begin
  371. CheckToken(tsqlAfter,'AFTER');
  372. end;
  373. procedure TTestSQLScanner.TestEmpty;
  374. Var
  375. J : TSQLToken;
  376. begin
  377. CreateScanner('');
  378. J:=Scanner.FetchToken;
  379. If (J<>tsqlEOF) then
  380. Fail('Empty returns EOF');
  381. end;
  382. procedure TTestSQLScanner.TestEnd;
  383. begin
  384. CheckToken(tsqlEnd,'END');
  385. end;
  386. procedure TTestSQLScanner.TestEntryPoint;
  387. begin
  388. CheckToken(tsqlEntryPoint,'ENTRY_POINT');
  389. end;
  390. procedure TTestSQLScanner.TestEscape;
  391. begin
  392. CheckToken(tsqlEscape,'ESCAPE');
  393. end;
  394. procedure TTestSQLScanner.TestException;
  395. begin
  396. CheckToken(tsqlException,'EXCEPTION');
  397. end;
  398. procedure TTestSQLScanner.TestExists;
  399. begin
  400. CheckToken(tsqlExists,'EXISTS');
  401. end;
  402. procedure TTestSQLScanner.TestExit;
  403. begin
  404. CheckToken(tsqlExit,'EXIT');
  405. end;
  406. procedure TTestSQLScanner.TestExternal;
  407. begin
  408. CheckToken(tsqlExternal,'external');
  409. end;
  410. procedure TTestSQLScanner.TestExtract;
  411. begin
  412. CheckToken(tsqlExtract,'EXTRACT');
  413. end;
  414. procedure TTestSQLScanner.TestAnd;
  415. begin
  416. CheckToken(tsqlAnd,'and');
  417. end;
  418. procedure TTestSQLScanner.TestAny;
  419. begin
  420. CheckToken(tsqlAny,'any');
  421. end;
  422. procedure TTestSQLScanner.TestAs;
  423. begin
  424. CheckToken(tsqlAs,'as');
  425. end;
  426. procedure TTestSQLScanner.TestAt;
  427. begin
  428. CheckToken(tsqlAt,'at');
  429. end;
  430. procedure TTestSQLScanner.TestAuto;
  431. begin
  432. CheckToken(tsqlAUTO,'auto');
  433. end;
  434. procedure TTestSQLScanner.TestASC;
  435. begin
  436. CheckToken(tsqlASC,'asc');
  437. end;
  438. procedure TTestSQLScanner.TestASCENDING;
  439. begin
  440. CheckToken(tsqlASCENDING,'ascending');
  441. end;
  442. procedure TTestSQLScanner.TestAVG;
  443. begin
  444. CheckToken(tsqlAVG,'avg');
  445. end;
  446. procedure TTestSQLScanner.TestALTER;
  447. begin
  448. CheckToken(tsqlALTER,'alter');
  449. end;
  450. procedure TTestSQLScanner.TestBraceOpen;
  451. begin
  452. CheckToken(tsqlBraceOpen,'(');
  453. end;
  454. procedure TTestSQLScanner.TestBraceClose;
  455. begin
  456. CheckToken(tsqlBraceClose,')');
  457. end;
  458. procedure TTestSQLScanner.TestComma;
  459. begin
  460. CheckToken(tsqlComma,',');
  461. end;
  462. procedure TTestSQLScanner.TestCommit;
  463. begin
  464. CheckToken(tsqlCommit,'COMMIT');
  465. end;
  466. procedure TTestSQLScanner.TestComputed;
  467. begin
  468. CheckToken(tsqlComputed,'COMPUTED');
  469. end;
  470. procedure TTestSQLScanner.TestConditional;
  471. begin
  472. CheckToken(tsqlConditional,'CONDITIONAL');
  473. end;
  474. procedure TTestSQLScanner.TestConnect;
  475. begin
  476. CheckToken(tsqlConnect,'CONNECT');
  477. end;
  478. procedure TTestSQLScanner.TestConstraint;
  479. begin
  480. CheckToken(tsqlConstraint,'CONSTRAINT');
  481. end;
  482. procedure TTestSQLScanner.TestColon;
  483. begin
  484. CheckToken(tsqlColon,':');
  485. end;
  486. procedure TTestSQLScanner.TestColumn;
  487. begin
  488. CheckToken(tsqlColumn,'COLUMN');
  489. end;
  490. procedure TTestSQLScanner.TestDot;
  491. begin
  492. CheckToken(tsqlDot,'.');
  493. end;
  494. procedure TTestSQLScanner.TestDrop;
  495. begin
  496. CheckToken(tsqldrop,'DROP');
  497. end;
  498. procedure TTestSQLScanner.TestSemicolon;
  499. begin
  500. CheckToken(tsqlSemicolon,';');
  501. end;
  502. procedure TTestSQLScanner.TestSet;
  503. begin
  504. CheckToken(tsqlSet,'SET');
  505. end;
  506. procedure TTestSQLScanner.TestSchema;
  507. begin
  508. CheckToken(tsqlSchema,'SCHEMA');
  509. end;
  510. procedure TTestSQLScanner.TestShadow;
  511. begin
  512. CheckToken(tsqlShadow,'SHADOW');
  513. end;
  514. procedure TTestSQLScanner.TestSingular;
  515. begin
  516. CheckToken(tsqlSINGULAR,'SINGULAR');
  517. end;
  518. procedure TTestSQLScanner.TestSize;
  519. begin
  520. CheckToken(tsqlSize,'size');
  521. end;
  522. procedure TTestSQLScanner.TestSkip;
  523. begin
  524. CheckToken(tsqlSkip,'skip');
  525. end;
  526. procedure TTestSQLScanner.TestSome;
  527. begin
  528. CheckToken(tsqlSome,'some');
  529. end;
  530. procedure TTestSQLScanner.TestSort;
  531. begin
  532. CheckToken(tsqlSort,'sort');
  533. end;
  534. procedure TTestSQLScanner.TestSnapshot;
  535. begin
  536. CheckToken(tsqlSnapshot,'snapshot');
  537. end;
  538. procedure TTestSQLScanner.TestSQLCode;
  539. begin
  540. CheckToken(tsqlSQLCOde,'SQLCODE');
  541. end;
  542. procedure TTestSQLScanner.TestSquareBraceClose;
  543. begin
  544. CheckToken(tsqlSquareBraceClose,']');
  545. end;
  546. procedure TTestSQLScanner.TestSquareBraceOpen;
  547. begin
  548. CheckToken(tsqlSquareBraceOpen,'[');
  549. end;
  550. procedure TTestSQLScanner.TestSubtype;
  551. begin
  552. CheckToken(tsqlSubtype,'sub_type');
  553. end;
  554. procedure TTestSQLScanner.TestSuspend;
  555. begin
  556. CheckToken(tsqlSuspend,'Suspend');
  557. end;
  558. procedure TTestSQLScanner.TestStarting;
  559. begin
  560. CheckToken(tsqlStarting,'starting');
  561. end;
  562. procedure TTestSQLScanner.TestSum;
  563. begin
  564. CheckToken(tsqlSum,'sum');
  565. end;
  566. procedure TTestSQLScanner.TestString;
  567. begin
  568. DoTestString('''A string''');
  569. DoTestString('''''');
  570. DoTestString(''' " ''');
  571. DoTestString('''A string''');
  572. DoTestString(''' '''' ''',True);
  573. DoTestString('''12345'#10'67890''');
  574. DoTestString('''12345'#13'67890''');
  575. DoTestString('''12345'#13#10'67890''');
  576. end;
  577. procedure TTestSQLScanner.TestTable;
  578. begin
  579. CheckToken(tsqltable,'TABLE');
  580. end;
  581. procedure TTestSQLScanner.TestThen;
  582. begin
  583. CheckToken(tsqlThen,'THEN');
  584. end;
  585. procedure TTestSQLScanner.TestTime;
  586. begin
  587. CheckToken(tsqlTime,'TIME');
  588. end;
  589. procedure TTestSQLScanner.TestTimeStamp;
  590. begin
  591. CheckToken(tsqlTimeStamp,'TIMESTAMP');
  592. end;
  593. procedure TTestSQLScanner.TestTo;
  594. begin
  595. CheckToken(tsqlTo,'TO');
  596. end;
  597. procedure TTestSQLScanner.TestTransaction;
  598. begin
  599. CheckToken(tsqlTransaction,'TRANSACTION');
  600. end;
  601. procedure TTestSQLScanner.TestTrigger;
  602. begin
  603. CheckToken(tsqlTrigger,'TRIGGER');
  604. end;
  605. procedure TTestSQLScanner.TestType;
  606. begin
  607. CheckToken(tsqltype,'TYPE');
  608. end;
  609. procedure TTestSQLScanner.TestUnion;
  610. begin
  611. CheckToken(tsqlUnion,'UNION');
  612. end;
  613. procedure TTestSQLScanner.TestUnique;
  614. begin
  615. CheckToken(tsqlUnique,'UNIQUE');
  616. end;
  617. procedure TTestSQLScanner.TestUpdate;
  618. begin
  619. CheckToken(tsqlUPDATE,'UPDATE');
  620. end;
  621. procedure TTestSQLScanner.TestUpper;
  622. begin
  623. CheckToken(tsqlUPPER,'UPPER');
  624. end;
  625. procedure TTestSQLScanner.TestUser;
  626. begin
  627. CheckToken(tsqlUSER,'USER');
  628. end;
  629. procedure TTestSQLScanner.TestValues;
  630. begin
  631. CheckToken(tsqlVALUES,'VALUES');
  632. end;
  633. procedure TTestSQLScanner.TestValue;
  634. begin
  635. CheckToken(tsqlVALUE,'VALUE');
  636. end;
  637. procedure TTestSQLScanner.TestAssign;
  638. begin
  639. CheckToken(tsqlEq,'=');
  640. end;
  641. procedure TTestSQLScanner.TestBefore;
  642. begin
  643. CheckToken(tsqlbefore,'BEFORE');
  644. end;
  645. procedure TTestSQLScanner.TestBegin;
  646. begin
  647. CheckToken(tsqlbegin,'BEGIN');
  648. end;
  649. procedure TTestSQLScanner.TestBetween;
  650. begin
  651. CheckToken(tsqlBetween,'BETWEEN');
  652. end;
  653. procedure TTestSQLScanner.TestGreaterThan;
  654. begin
  655. CheckToken(tsqlGT,'>');
  656. end;
  657. procedure TTestSQLScanner.TestGroup;
  658. begin
  659. CheckToken(tsqlGroup,'group');
  660. end;
  661. procedure TTestSQLScanner.TestHaving;
  662. begin
  663. CheckToken(tsqlHaving,'HAVING');
  664. end;
  665. procedure TTestSQLScanner.TestLessThan;
  666. begin
  667. CheckToken(tsqlLT,'<');
  668. end;
  669. procedure TTestSQLScanner.TestManual;
  670. begin
  671. Checktoken(tsqlManual,'manual');
  672. end;
  673. procedure TTestSQLScanner.TestModuleName;
  674. begin
  675. Checktoken(tsqlModuleName,'module_name');
  676. end;
  677. procedure TTestSQLScanner.TestMax;
  678. begin
  679. Checktoken(tsqlMax,'max');
  680. end;
  681. procedure TTestSQLScanner.TestMerge;
  682. begin
  683. Checktoken(tsqlMerge,'merge');
  684. end;
  685. procedure TTestSQLScanner.TestMin;
  686. begin
  687. Checktoken(tsqlMin,'min');
  688. end;
  689. procedure TTestSQLScanner.TestPlus;
  690. begin
  691. CheckToken(tsqlPlus,'+');
  692. end;
  693. procedure TTestSQLScanner.TestPosition;
  694. begin
  695. Checktoken(tsqlposition,'position');
  696. end;
  697. procedure TTestSQLScanner.TestPostEvent;
  698. begin
  699. Checktoken(tsqlpostevent,'post_event');
  700. end;
  701. procedure TTestSQLScanner.TestPrimary;
  702. begin
  703. Checktoken(tsqlprimary,'primary');
  704. end;
  705. procedure TTestSQLScanner.TestPrivileges;
  706. begin
  707. Checktoken(tsqlprivileges,'privileges');
  708. end;
  709. procedure TTestSQLScanner.TestProcedure;
  710. begin
  711. Checktoken(tsqlprocedure,'procedure');
  712. end;
  713. procedure TTestSQLScanner.TestPublic;
  714. begin
  715. CheckToken(tsqlPublic,'PUBLIC');
  716. end;
  717. procedure TTestSQLScanner.TestReferences;
  718. begin
  719. CheckToken(tsqlReferences,'REFERENCES');
  720. end;
  721. procedure TTestSQLScanner.TestRelease;
  722. begin
  723. CheckToken(tsqlrelease,'release');
  724. end;
  725. procedure TTestSQLScanner.TestReturningValues;
  726. begin
  727. CheckToken(tsqlreturningvalues,'returning_values');
  728. end;
  729. procedure TTestSQLScanner.TestReturns;
  730. begin
  731. CheckToken(tsqlreturns,'returns');
  732. end;
  733. procedure TTestSQLScanner.TestRetain;
  734. begin
  735. Checktoken(tsqlRetain,'retain');
  736. end;
  737. procedure TTestSQLScanner.TestRevoke;
  738. begin
  739. Checktoken(tsqlRevoke,'revoke');
  740. end;
  741. procedure TTestSQLScanner.TestRight;
  742. begin
  743. Checktoken(tsqlright,'right');
  744. end;
  745. procedure TTestSQLScanner.TestRole;
  746. begin
  747. Checktoken(tsqlrole,'role');
  748. end;
  749. procedure TTestSQLScanner.TestRollback;
  750. begin
  751. Checktoken(tsqlrollback,'rollback');
  752. end;
  753. procedure TTestSQLScanner.TestSegment;
  754. begin
  755. CheckToken(tsqlSegment,'SEGMENT');
  756. end;
  757. procedure TTestSQLScanner.TestSelect;
  758. begin
  759. CheckToken(tsqlSelect,'SELECT');
  760. end;
  761. procedure TTestSQLScanner.TestMinus;
  762. begin
  763. CheckToken(tsqlMinus,'-');
  764. end;
  765. procedure TTestSQLScanner.TestMul;
  766. begin
  767. CheckToken(tsqlMul,'*');
  768. end;
  769. procedure TTestSQLScanner.TestNational;
  770. begin
  771. CheckToken(tsqlNational,'NATIONAL');
  772. end;
  773. procedure TTestSQLScanner.TestNatural;
  774. begin
  775. CheckToken(tsqlNatural,'NATURAL');
  776. end;
  777. procedure TTestSQLScanner.TestDiv;
  778. begin
  779. CheckToken(tsqlDiv,'/');
  780. end;
  781. procedure TTestSQLScanner.TestEq;
  782. begin
  783. CheckToken(tsqlEq,'==');
  784. end;
  785. procedure TTestSQLScanner.TestFloat;
  786. begin
  787. CheckToken(tsqlFloat,'FLOAT');
  788. end;
  789. procedure TTestSQLScanner.TestGE;
  790. begin
  791. CheckToken(tsqlGE,'>=');
  792. end;
  793. procedure TTestSQLScanner.TestGenerator;
  794. begin
  795. CheckToken(tsqlGenerator,'generator');
  796. end;
  797. procedure TTestSQLScanner.TestGrant;
  798. begin
  799. CheckToken(tsqlGrant,'grant');
  800. end;
  801. procedure TTestSQLScanner.TestLE;
  802. begin
  803. CheckToken(tsqlLE,'<=');
  804. end;
  805. procedure TTestSQLScanner.TestNE;
  806. begin
  807. CheckToken(tsqlNE,'<>');
  808. end;
  809. procedure TTestSQLScanner.TestNo;
  810. begin
  811. CheckToken(tsqlNo,'no');
  812. end;
  813. procedure TTestSQLScanner.TestNot;
  814. begin
  815. CheckToken(tsqlNot,'not');
  816. end;
  817. procedure TTestSQLScanner.TestNull;
  818. begin
  819. CheckToken(tsqlnull,'null');
  820. end;
  821. procedure TTestSQLScanner.TestNumeric;
  822. begin
  823. CheckToken(tsqlNumeric,'NUMERIC');
  824. end;
  825. procedure TTestSQLScanner.TestOn;
  826. begin
  827. CheckToken(tsqlON,'on');
  828. end;
  829. procedure TTestSQLScanner.TestOption;
  830. begin
  831. CheckToken(tsqlOption,'option');
  832. end;
  833. procedure TTestSQLScanner.TestOr;
  834. begin
  835. CheckToken(tsqlOR,'or');
  836. end;
  837. procedure TTestSQLScanner.TestOrder;
  838. begin
  839. CheckToken(tsqlORDER,'order');
  840. end;
  841. procedure TTestSQLScanner.TestOuter;
  842. begin
  843. CheckToken(tsqlOUTER,'outer');
  844. end;
  845. procedure TTestSQLScanner.TestPage;
  846. begin
  847. CheckToken(tsqlPage,'PAGE');
  848. end;
  849. procedure TTestSQLScanner.TestPages;
  850. begin
  851. CheckToken(tsqlPages,'PAGES');
  852. end;
  853. procedure TTestSQLScanner.TestPageSize;
  854. begin
  855. CheckToken(tsqlPageSize,'PAGE_SIZE');
  856. end;
  857. procedure TTestSQLScanner.TestPassword;
  858. begin
  859. CheckToken(tsqlPassword,'PASSWORD');
  860. end;
  861. {
  862. procedure TTestSQLScanner.TestTrue;
  863. begin
  864. CheckToken(tsqlTrue,'true');
  865. end;
  866. procedure TTestSQLScanner.TestFalse;
  867. begin
  868. CheckToken(tsqlFalse,'false');
  869. end;
  870. }
  871. procedure TTestSQLScanner.TestBy;
  872. begin
  873. CheckToken(tsqlBy,'by');
  874. end;
  875. procedure TTestSQLScanner.TestCache;
  876. begin
  877. CheckToken(tsqlCache,'CACHE');
  878. end;
  879. procedure TTestSQLScanner.TestCascade;
  880. begin
  881. CheckToken(tsqlCascade,'cascade');
  882. end;
  883. procedure TTestSQLScanner.TestBlob;
  884. begin
  885. CheckToken(tsqlBlob,'blob');
  886. end;
  887. procedure TTestSQLScanner.TestChar;
  888. begin
  889. CheckToken(tsqlChar,'char');
  890. end;
  891. procedure TTestSQLScanner.TestCharacter;
  892. begin
  893. CheckToken(tsqlCharacter,'character');
  894. end;
  895. procedure TTestSQLScanner.TestCheck;
  896. begin
  897. CheckToken(tsqlCHECK,'check');
  898. end;
  899. procedure TTestSQLScanner.TestCollate;
  900. begin
  901. CheckToken(tsqlCollate,'collate');
  902. end;
  903. procedure TTestSQLScanner.TestConcatenate;
  904. begin
  905. CheckToken(tsqlConcatenate,'||');
  906. end;
  907. procedure TTestSQLScanner.TestContaining;
  908. begin
  909. CheckToken(tsqlContaining,'containing');
  910. end;
  911. procedure TTestSQLScanner.TestCount;
  912. begin
  913. CheckToken(tsqlCount,'count');
  914. end;
  915. procedure TTestSQLScanner.TestCreate;
  916. begin
  917. CheckToken(tsqlCreate,'create');
  918. end;
  919. procedure TTestSQLScanner.TestCString;
  920. begin
  921. CheckToken(tsqlCString,'CSTRING');
  922. end;
  923. procedure TTestSQLScanner.TestDatabase;
  924. begin
  925. CheckToken(tsqlDatabase,'database');
  926. end;
  927. procedure TTestSQLScanner.TestDate;
  928. begin
  929. CheckToken(tsqlDate,'date');
  930. end;
  931. procedure TTestSQLScanner.TestDecimal;
  932. begin
  933. CheckToken(tsqlDecimal,'decimal');
  934. end;
  935. procedure TTestSQLScanner.TestDefault;
  936. begin
  937. CheckToken(tsqldefault,'default');
  938. end;
  939. procedure TTestSQLScanner.TestDelete;
  940. begin
  941. CheckToken(tsqldelete,'delete');
  942. end;
  943. procedure TTestSQLScanner.TestDeclare;
  944. begin
  945. CheckToken(tsqlDeclare,'DECLARE');
  946. end;
  947. procedure TTestSQLScanner.TestDesc;
  948. begin
  949. CheckToken(tsqlDESC,'DESC');
  950. end;
  951. procedure TTestSQLScanner.TestDescending;
  952. begin
  953. CheckToken(tsqlDescending,'DESCENDING');
  954. end;
  955. procedure TTestSQLScanner.TestDistinct;
  956. begin
  957. CheckToken(tsqlDistinct,'DISTINCT');
  958. end;
  959. procedure TTestSQLScanner.TestDO;
  960. begin
  961. CheckToken(tsqldo,'do');
  962. end;
  963. procedure TTestSQLScanner.TestDomain;
  964. begin
  965. CheckToken(tsqlDomain,'domain');
  966. end;
  967. procedure TTestSQLScanner.TestElse;
  968. begin
  969. CheckToken(tsqlelse,'else');
  970. end;
  971. procedure TTestSQLScanner.TestFor;
  972. begin
  973. CheckToken(tsqlfor,'for');
  974. end;
  975. procedure TTestSQLScanner.TestForeign;
  976. begin
  977. CheckToken(tsqlForeign,'foreign');
  978. end;
  979. procedure TTestSQLScanner.TestFreeIt;
  980. begin
  981. CheckToken(tsqlFreeIt,'FREE_IT');
  982. end;
  983. procedure TTestSQLScanner.TestFile;
  984. begin
  985. CheckToken(tsqlFile,'FILE');
  986. end;
  987. procedure TTestSQLScanner.TestFunction;
  988. begin
  989. CheckToken(tsqlfunction,'function');
  990. end;
  991. procedure TTestSQLScanner.TestGDSError;
  992. begin
  993. CheckToken(tsqlGDSCODE,'GDSCODE');
  994. end;
  995. procedure TTestSQLScanner.TestIf;
  996. begin
  997. CheckToken(tsqlif,'if');
  998. end;
  999. procedure TTestSQLScanner.TestIn;
  1000. begin
  1001. CheckToken(tsqlin,'in');
  1002. end;
  1003. procedure TTestSQLScanner.TestInner;
  1004. begin
  1005. CheckToken(tsqlInner,'inner');
  1006. end;
  1007. procedure TTestSQLScanner.TestInsert;
  1008. begin
  1009. CheckToken(tsqlInsert,'insert');
  1010. end;
  1011. procedure TTestSQLScanner.TestInt;
  1012. begin
  1013. CheckToken(tsqlInt,'int');
  1014. end;
  1015. procedure TTestSQLScanner.TestInteger;
  1016. begin
  1017. CheckToken(tsqlInteger,'integer');
  1018. end;
  1019. procedure TTestSQLScanner.TestInto;
  1020. begin
  1021. CheckToken(tsqlInto,'into');
  1022. end;
  1023. procedure TTestSQLScanner.TestIs;
  1024. begin
  1025. CheckToken(tsqlis,'is');
  1026. end;
  1027. procedure TTestSQLScanner.TestJoin;
  1028. begin
  1029. CheckToken(tsqlJoin,'JOIN');
  1030. end;
  1031. procedure TTestSQLScanner.TestKey;
  1032. begin
  1033. CheckToken(tsqlKey,'KEY');
  1034. end;
  1035. procedure TTestSQLScanner.TestLeft;
  1036. begin
  1037. CheckToken(tsqlLEFT,'LEFT');
  1038. end;
  1039. procedure TTestSQLScanner.TestLength;
  1040. begin
  1041. CheckToken(tsqlLength,'LENGTH');
  1042. end;
  1043. procedure TTestSQLScanner.TestLike;
  1044. begin
  1045. CheckToken(tsqlLIKE,'LIKE');
  1046. end;
  1047. procedure TTestSQLScanner.TestIndex;
  1048. begin
  1049. CheckToken(tsqlindex,'index');
  1050. end;
  1051. procedure TTestSQLScanner.TestVariable;
  1052. begin
  1053. CheckToken(tsqlvariable,'variable');
  1054. end;
  1055. procedure TTestSQLScanner.TestVarChar;
  1056. begin
  1057. CheckToken(tsqlvarchar,'varchar');
  1058. end;
  1059. procedure TTestSQLScanner.TestVarying;
  1060. begin
  1061. CheckToken(tsqlvarying,'varying');
  1062. end;
  1063. procedure TTestSQLScanner.TestView;
  1064. begin
  1065. CheckToken(tsqlview,'view');
  1066. end;
  1067. procedure TTestSQLScanner.TestWhen;
  1068. begin
  1069. CheckToken(tsqlWhen,'when');
  1070. end;
  1071. procedure TTestSQLScanner.TestWhere;
  1072. begin
  1073. CheckToken(tsqlwhere,'where');
  1074. end;
  1075. procedure TTestSQLScanner.TestWhile;
  1076. begin
  1077. CheckToken(tsqlwhile,'while');
  1078. end;
  1079. procedure TTestSQLScanner.TestWith;
  1080. begin
  1081. CheckToken(tsqlwith,'with');
  1082. end;
  1083. procedure TTestSQLScanner.TestWork;
  1084. begin
  1085. CheckToken(tsqlWork,'work');
  1086. end;
  1087. procedure TTestSQLScanner.CheckTokens(ASource : String; ATokens : Array of TSQLToken);
  1088. Var
  1089. I : Integer;
  1090. J : TSQLToken;
  1091. S : String;
  1092. begin
  1093. CreateScanner(ASource);
  1094. For I:=Low(ATokens) to High(ATokens) do
  1095. begin
  1096. J:=FScanner.FetchToken;
  1097. S:=GetEnumName(TypeINfo(TSQLToken),Ord(ATokens[i]));
  1098. S:=Format('Source "%s", token %d (%s): expected %s',[ASource,I,FScanner.CurTokenString,S]);
  1099. AssertEquals(S,ATokens[i],J);
  1100. end;
  1101. end;
  1102. procedure TTestSQLScanner.Test2Words;
  1103. begin
  1104. CheckTokens('with do',[tsqlWith,tsqlDo]);
  1105. end;
  1106. procedure TTestSQLScanner.Test3Words;
  1107. begin
  1108. CheckTokens('with do for',[tsqlWith,tsqlDo,tsqlFor]);
  1109. end;
  1110. procedure TTestSQLScanner.TestIdentifier;
  1111. begin
  1112. CheckToken(tsqlIdentifier,'something');
  1113. AssertEquals('Correct identifier','something',FScanner.CurTokenString);
  1114. end;
  1115. procedure TTestSQLScanner.TestIdentifier2;
  1116. begin
  1117. CheckToken(tsqlIdentifier,'"_something"');
  1118. AssertEquals('Correct identifier','_something',FScanner.CurTokenString);
  1119. end;
  1120. procedure TTestSQLScanner.TestIdentifier3;
  1121. begin
  1122. CheckToken(tsqlIdentifier,'RDB$');
  1123. AssertEquals('Correct identifier','RDB$',FScanner.CurTokenString);
  1124. end;
  1125. procedure TTestSQLScanner.TestIdentifier4;
  1126. begin
  1127. CheckToken(tsqlIdentifier,'A_0');
  1128. AssertEquals('Correct identifier','A_0',FScanner.CurTokenString);
  1129. end;
  1130. procedure TTestSQLScanner.TestIdentifier5;
  1131. begin
  1132. FErrorSource:='$0';
  1133. AssertException('Identifier cannot start with _',ESQLScannerError,@TestErrorSource);
  1134. end;
  1135. procedure TTestSQLScanner.TestIdentifierDotIdentifier;
  1136. begin
  1137. CheckTokens('something.different',[tsqlIdentifier,tsqldot,tsqlIdentifier]);
  1138. // AssertEquals('Correct identifier','something',FScanner.CurTokenString);
  1139. end;
  1140. procedure TTestSQLScanner.TestEOLN;
  1141. begin
  1142. CreateScanner('something');
  1143. FScanner.FetchToken;
  1144. AssertEquals('Got to end of line after reading single token at EOF',True,FScanner.IsEndOfLine);
  1145. // AssertEquals('Correct identifier','something',FScanner.CurTokenString);
  1146. end;
  1147. procedure TTestSQLScanner.TestEOLN2;
  1148. begin
  1149. CreateScanner('something different');
  1150. FScanner.FetchToken;
  1151. AssertEquals('Not yet end of line after reading single token at EOF',False,FScanner.IsEndOfLine);
  1152. end;
  1153. procedure TTestSQLScanner.TestEOLN3;
  1154. begin
  1155. CreateScanner('something'#13#10'different');
  1156. FScanner.FetchToken;
  1157. AssertEquals('End of line after reading single token',True,FScanner.IsEndOfLine);
  1158. end;
  1159. procedure TTestSQLScanner.TestEOLN4;
  1160. begin
  1161. CreateScanner('something'#10'different');
  1162. FScanner.FetchToken;
  1163. AssertEquals('End of line after reading first token',True,FScanner.IsEndOfLine);
  1164. FScanner.FetchToken;
  1165. AssertEquals('End of line after reading second token',True,FScanner.IsEndOfLine);
  1166. end;
  1167. procedure TTestSQLScanner.TestComment1;
  1168. begin
  1169. CreateScanner('-- some comment string');
  1170. AssertEquals('Comment line is skipped',tsqlEOF,FScanner.FetchToken);
  1171. end;
  1172. procedure TTestSQLScanner.TestComment2;
  1173. begin
  1174. CreateScanner('-- some comment string');
  1175. FScanner.Options:=[soReturnComments];
  1176. AssertEquals('Comment line is returned',tsqlComment,FScanner.FetchToken);
  1177. AssertEquals('Comment contents is returned',' some comment string',FScanner.CurTokenString);
  1178. end;
  1179. procedure TTestSQLScanner.TestComment3;
  1180. begin
  1181. CreateScanner('/* some comment string */');
  1182. AssertEquals('Comment line is skipped',tsqlEOF,FScanner.FetchToken);
  1183. end;
  1184. procedure TTestSQLScanner.TestComment4;
  1185. begin
  1186. CreateScanner('/* some comment string */');
  1187. FScanner.Options:=[soReturnComments];
  1188. AssertEquals('Comment line is returned',tsqlComment,FScanner.FetchToken);
  1189. AssertEquals('Comment contents is returned',' some comment string ',FScanner.CurTokenString);
  1190. end;
  1191. procedure TTestSQLScanner.TestComment5;
  1192. begin
  1193. CreateScanner('/* some nested comment -- string */');
  1194. FScanner.Options:=[soReturnComments];
  1195. AssertEquals('Comment line is returned',tsqlComment,FScanner.FetchToken);
  1196. AssertEquals('Comment contents is returned',' some nested comment -- string ',FScanner.CurTokenString);
  1197. end;
  1198. procedure TTestSQLScanner.TestComment6;
  1199. begin
  1200. CreateScanner('-- /* some nested comment string */');
  1201. FScanner.Options:=[soReturnComments];
  1202. AssertEquals('Comment line is returned',tsqlComment,FScanner.FetchToken);
  1203. AssertEquals('Comment contents is returned','/* some nested comment string */',FScanner.CurTokenString);
  1204. end;
  1205. procedure TTestSQLScanner.TestFloatLiteral;
  1206. begin
  1207. DoTestFloat(1.2);
  1208. DoTestFloat(-1.2);
  1209. DoTestFloat(1.2e1);
  1210. DoTestFloat(-1.2e1);
  1211. DoTestFloat(1.2,'1.2');
  1212. DoTestFloat(-1.2,'-1.2');
  1213. DoTestFloat(0,'0.0');
  1214. end;
  1215. procedure TTestSQLScanner.TestStringLiteral1;
  1216. begin
  1217. CreateScanner('''A''');
  1218. FScanner.Options:=[];
  1219. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1220. AssertEquals('Correct string','A',FScanner.CurTokenString);
  1221. end;
  1222. procedure TTestSQLScanner.TestStringLiteral2;
  1223. begin
  1224. CreateScanner('"A"',[soDoubleQuoteStringLiteral]);
  1225. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1226. AssertEquals('Correct string','A',FScanner.CurTokenString);
  1227. end;
  1228. procedure TTestSQLScanner.TestStringError;
  1229. begin
  1230. end;
  1231. procedure TTestSQLScanner.TestFloatError;
  1232. begin
  1233. FErrorSource:='1xz';
  1234. AssertException('Wrong float',ESQLScannerError,@TestErrorSource);
  1235. end;
  1236. procedure TTestSQLScanner.TestOptionsoDoubleQuoteStringLiteral;
  1237. begin
  1238. CreateScanner('"A"',[soDoubleQuoteStringLiteral]);
  1239. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1240. AssertEquals('Correct string','A',FScanner.CurTokenString);
  1241. end;
  1242. procedure TTestSQLScanner.TestOptionsoSingleQuoteIdentifier;
  1243. begin
  1244. CreateScanner('''A''',[soSingleQuoteIdentifier,soDoubleQuoteStringLiteral]);
  1245. If (Scanner.Options<>[soSingleQuoteIdentifier,soDoubleQuoteStringLiteral]) then
  1246. Fail('Options not correctly set');
  1247. AssertEquals('Identifier is returned',tsqlIdentifier,FScanner.FetchToken);
  1248. AssertEquals('Correct string','A',FScanner.CurTokenString);
  1249. end;
  1250. procedure TTestSQLScanner.TestOptionsoBackQuoteIdentifier;
  1251. begin
  1252. CreateScanner('`A`',[soBackQuoteIdentifier]);
  1253. AssertEquals('String is returned',tsqlIdentifier,FScanner.FetchToken);
  1254. AssertEquals('Correct string','A',FScanner.CurTokenString);
  1255. end;
  1256. procedure TTestSQLScanner.TestOptionNosoBackQuoteIdentifier;
  1257. begin
  1258. FErrorSource:='`A`';
  1259. AssertException('Wrong token',ESQLScannerError,@TestErrorSource);
  1260. end;
  1261. procedure TTestSQLScanner.TestOptionsoBackslashEscapesTab;
  1262. begin
  1263. CreateScanner('''\t''',[soBackslashEscapes]);
  1264. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1265. AssertEquals('Correct string',#9,FScanner.CurTokenString);
  1266. end;
  1267. procedure TTestSQLScanner.TestOptionsoBackslashEscapesNewLine;
  1268. begin
  1269. CreateScanner('''\n''',[soBackslashEscapes]);
  1270. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1271. AssertEquals('Correct string',#10,FScanner.CurTokenString);
  1272. end;
  1273. procedure TTestSQLScanner.TestOptionsoBackslashEscapesLineFeed;
  1274. begin
  1275. CreateScanner('''\r''',[soBackslashEscapes]);
  1276. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1277. AssertEquals('Correct string',#13,FScanner.CurTokenString);
  1278. end;
  1279. procedure TTestSQLScanner.TestOptionsoBackslashEscapesBackSlash;
  1280. begin
  1281. CreateScanner('''\\''',[soBackslashEscapes]);
  1282. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1283. AssertEquals('Correct string','\',FScanner.CurTokenString);
  1284. end;
  1285. procedure TTestSQLScanner.TestOptionsoBackslashEscapesNewPage;
  1286. begin
  1287. CreateScanner('''\f''',[soBackslashEscapes]);
  1288. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1289. AssertEquals('Correct string',#12,FScanner.CurTokenString);
  1290. end;
  1291. procedure TTestSQLScanner.TestOptionsoBackslashEscapesSlash;
  1292. begin
  1293. CreateScanner('''\/''',[soBackslashEscapes]);
  1294. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1295. AssertEquals('Correct string','/',FScanner.CurTokenString);
  1296. end;
  1297. procedure TTestSQLScanner.TestOptionsoBackslashEscapesBackspace;
  1298. begin
  1299. CreateScanner('''\f''',[soBackslashEscapes]);
  1300. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1301. AssertEquals('Correct string',#12,FScanner.CurTokenString);
  1302. end;
  1303. procedure TTestSQLScanner.TestOptionsoBackslashEscapesQuote;
  1304. begin
  1305. CreateScanner('''\''''',[soBackslashEscapes]);
  1306. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1307. AssertEquals('Correct string','''',FScanner.CurTokenString);
  1308. end;
  1309. procedure TTestSQLScanner.TestOptionsoBackslashEscapesDoubleQuote;
  1310. begin
  1311. CreateScanner('''\"''',[soBackslashEscapes]);
  1312. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1313. AssertEquals('Correct string','"',FScanner.CurTokenString);
  1314. end;
  1315. procedure TTestSQLScanner.TestOptionNosoBackslashEscapes;
  1316. begin
  1317. CreateScanner('''\"''',[]);
  1318. AssertEquals('String is returned',tsqlString,FScanner.FetchToken);
  1319. AssertEquals('Correct string','\"',FScanner.CurTokenString);
  1320. end;
  1321. initialization
  1322. RegisterTest(TTestSQLScanner);
  1323. end.