unittest.pascal.pp 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832
  1. {
  2. This file is part of the Free Component Library (FCL)
  3. Copyright (c) 2025 by Michael Van Canneyt
  4. Pascal highlighter unit test
  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 unittest.pascal;
  12. interface
  13. {$mode objfpc}{$H+}
  14. uses
  15. Classes, SysUtils, fpcunit, testregistry,
  16. syntax.highlighter, syntax.pascal;
  17. type
  18. TTestPascalHighlighter = class(TTestCase)
  19. protected
  20. procedure SetUp; override;
  21. procedure TearDown; override;
  22. private
  23. published
  24. procedure TestBasicKeywords;
  25. procedure TestANDKeyword;
  26. procedure TestARRAYKeyword;
  27. procedure TestASMKeyword;
  28. procedure TestASSEMBLERKeyword;
  29. procedure TestBEGINKeyword;
  30. procedure TestBREAKKeyword;
  31. procedure TestCASEKeyword;
  32. procedure TestCONSTKeyword;
  33. procedure TestCONSTRUCTORKeyword;
  34. procedure TestCLASSKeyword;
  35. procedure TestDEFAULTKeyword;
  36. procedure TestDESTRUCTORKeyword;
  37. procedure TestDIVKeyword;
  38. procedure TestDOKeyword;
  39. procedure TestDOWNTOKeyword;
  40. procedure TestELSEKeyword;
  41. procedure TestENDKeyword;
  42. procedure TestEXCEPTKeyword;
  43. procedure TestEXITKeyword;
  44. procedure TestFINALIZATIONKeyword;
  45. procedure TestFINALLYKeyword;
  46. procedure TestFORKeyword;
  47. procedure TestFUNCTIONKeyword;
  48. procedure TestGOTOKeyword;
  49. procedure TestIFKeyword;
  50. procedure TestIMPLEMENTATIONKeyword;
  51. procedure TestINKeyword;
  52. procedure TestINHERITEDKeyword;
  53. procedure TestINITIALIZATIONKeyword;
  54. procedure TestINTERFACEKeyword;
  55. procedure TestNILKeyword;
  56. procedure TestNOTKeyword;
  57. procedure TestOBJECTKeyword;
  58. procedure TestOFKeyword;
  59. procedure TestONKeyword;
  60. procedure TestORKeyword;
  61. procedure TestOVERRIDEKeyword;
  62. procedure TestPACKEDKeyword;
  63. procedure TestPRIVATEKeyword;
  64. procedure TestPROCEDUREKeyword;
  65. procedure TestPROGRAMKeyword;
  66. procedure TestPROPERTYKeyword;
  67. procedure TestPROTECTEDKeyword;
  68. procedure TestPUBLICKeyword;
  69. procedure TestPUBLISHEDKeyword;
  70. procedure TestRAISEKeyword;
  71. procedure TestRECORDKeyword;
  72. procedure TestREPEATKeyword;
  73. procedure TestRESOURCESTRINGKeyword;
  74. procedure TestSETKeyword;
  75. procedure TestTHENKeyword;
  76. procedure TestTRYKeyword;
  77. procedure TestTYPEKeyword;
  78. procedure TestUNITKeyword;
  79. procedure TestUNTILKeyword;
  80. procedure TestUSESKeyword;
  81. procedure TestVARKeyword;
  82. procedure TestVIRTUALKeyword;
  83. procedure TestWHILEKeyword;
  84. procedure TestWITHKeyword;
  85. procedure TestXORKeyword;
  86. procedure TestComments;
  87. procedure TestStrings;
  88. procedure TestNumbers;
  89. procedure TestSymbols;
  90. procedure TestDirectives;
  91. procedure TestIdentifiers;
  92. end;
  93. implementation
  94. procedure TTestPascalHighlighter.SetUp;
  95. begin
  96. end;
  97. procedure TTestPascalHighlighter.TearDown;
  98. begin
  99. // Nothing to do
  100. end;
  101. procedure TTestPascalHighlighter.TestBasicKeywords;
  102. var
  103. tokens: TSyntaxTokenArray;
  104. begin
  105. tokens := DoPascalHighlighting('begin end');
  106. AssertEquals('Should have 3 tokens', 3, Length(tokens));
  107. AssertEquals('First token should be BEGIN', 'begin', tokens[0].Text);
  108. AssertEquals('First token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  109. AssertEquals('Second token should be space', ' ', tokens[1].Text);
  110. AssertEquals('Second token should be default', Ord(shDefault), Ord(tokens[1].Kind));
  111. AssertEquals('Third token should be END', 'end', tokens[2].Text);
  112. AssertEquals('Third token should be keyword', Ord(shKeyword), Ord(tokens[2].Kind));
  113. end;
  114. procedure TTestPascalHighlighter.TestANDKeyword;
  115. var
  116. tokens: TSyntaxTokenArray;
  117. begin
  118. tokens := DoPascalHighlighting('and');
  119. AssertEquals('Should have 1 token', 1, Length(tokens));
  120. AssertEquals('Token should be AND', 'and', tokens[0].Text);
  121. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  122. end;
  123. procedure TTestPascalHighlighter.TestARRAYKeyword;
  124. var
  125. tokens: TSyntaxTokenArray;
  126. begin
  127. tokens := DoPascalHighlighting('array');
  128. AssertEquals('Should have 1 token', 1, Length(tokens));
  129. AssertEquals('Token should be ARRAY', 'array', tokens[0].Text);
  130. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  131. end;
  132. procedure TTestPascalHighlighter.TestASMKeyword;
  133. var
  134. tokens: TSyntaxTokenArray;
  135. begin
  136. tokens := DoPascalHighlighting('asm end');
  137. AssertTrue('Should have at least 2 tokens', Length(tokens) >= 2);
  138. AssertEquals('First token should be ASM', 'asm', tokens[0].Text);
  139. AssertEquals('First token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  140. // After ASM keyword, we should have assembler highlighting until END
  141. end;
  142. procedure TTestPascalHighlighter.TestASSEMBLERKeyword;
  143. var
  144. tokens: TSyntaxTokenArray;
  145. begin
  146. tokens := DoPascalHighlighting('assembler');
  147. AssertEquals('Should have 1 token', 1, Length(tokens));
  148. AssertEquals('Token should be ASSEMBLER', 'assembler', tokens[0].Text);
  149. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  150. end;
  151. procedure TTestPascalHighlighter.TestBEGINKeyword;
  152. var
  153. tokens: TSyntaxTokenArray;
  154. begin
  155. tokens := DoPascalHighlighting('begin');
  156. AssertEquals('Should have 1 token', 1, Length(tokens));
  157. AssertEquals('Token should be BEGIN', 'begin', tokens[0].Text);
  158. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  159. end;
  160. procedure TTestPascalHighlighter.TestBREAKKeyword;
  161. var
  162. tokens: TSyntaxTokenArray;
  163. begin
  164. tokens := DoPascalHighlighting('break');
  165. AssertEquals('Should have 1 token', 1, Length(tokens));
  166. AssertEquals('Token should be BREAK', 'break', tokens[0].Text);
  167. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  168. end;
  169. procedure TTestPascalHighlighter.TestCASEKeyword;
  170. var
  171. tokens: TSyntaxTokenArray;
  172. begin
  173. tokens := DoPascalHighlighting('case');
  174. AssertEquals('Should have 1 token', 1, Length(tokens));
  175. AssertEquals('Token should be CASE', 'case', tokens[0].Text);
  176. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  177. end;
  178. procedure TTestPascalHighlighter.TestCONSTKeyword;
  179. var
  180. tokens: TSyntaxTokenArray;
  181. begin
  182. tokens := DoPascalHighlighting('const');
  183. AssertEquals('Should have 1 token', 1, Length(tokens));
  184. AssertEquals('Token should be CONST', 'const', tokens[0].Text);
  185. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  186. end;
  187. procedure TTestPascalHighlighter.TestCONSTRUCTORKeyword;
  188. var
  189. tokens: TSyntaxTokenArray;
  190. begin
  191. tokens := DoPascalHighlighting('constructor');
  192. AssertEquals('Should have 1 token', 1, Length(tokens));
  193. AssertEquals('Token should be CONSTRUCTOR', 'constructor', tokens[0].Text);
  194. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  195. end;
  196. procedure TTestPascalHighlighter.TestCLASSKeyword;
  197. var
  198. tokens: TSyntaxTokenArray;
  199. begin
  200. tokens := DoPascalHighlighting('class');
  201. AssertEquals('Should have 1 token', 1, Length(tokens));
  202. AssertEquals('Token should be CLASS', 'class', tokens[0].Text);
  203. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  204. end;
  205. procedure TTestPascalHighlighter.TestDEFAULTKeyword;
  206. var
  207. tokens: TSyntaxTokenArray;
  208. begin
  209. tokens := DoPascalHighlighting('default');
  210. AssertEquals('Should have 1 token', 1, Length(tokens));
  211. AssertEquals('Token should be DEFAULT', 'default', tokens[0].Text);
  212. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  213. end;
  214. procedure TTestPascalHighlighter.TestDESTRUCTORKeyword;
  215. var
  216. tokens: TSyntaxTokenArray;
  217. begin
  218. tokens := DoPascalHighlighting('destructor');
  219. AssertEquals('Should have 1 token', 1, Length(tokens));
  220. AssertEquals('Token should be DESTRUCTOR', 'destructor', tokens[0].Text);
  221. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  222. end;
  223. procedure TTestPascalHighlighter.TestDIVKeyword;
  224. var
  225. tokens: TSyntaxTokenArray;
  226. begin
  227. tokens := DoPascalHighlighting('div');
  228. AssertEquals('Should have 1 token', 1, Length(tokens));
  229. AssertEquals('Token should be DIV', 'div', tokens[0].Text);
  230. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  231. end;
  232. procedure TTestPascalHighlighter.TestDOKeyword;
  233. var
  234. tokens: TSyntaxTokenArray;
  235. begin
  236. tokens := DoPascalHighlighting('do');
  237. AssertEquals('Should have 1 token', 1, Length(tokens));
  238. AssertEquals('Token should be DO', 'do', tokens[0].Text);
  239. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  240. end;
  241. procedure TTestPascalHighlighter.TestDOWNTOKeyword;
  242. var
  243. tokens: TSyntaxTokenArray;
  244. begin
  245. tokens := DoPascalHighlighting('downto');
  246. AssertEquals('Should have 1 token', 1, Length(tokens));
  247. AssertEquals('Token should be DOWNTO', 'downto', tokens[0].Text);
  248. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  249. end;
  250. procedure TTestPascalHighlighter.TestELSEKeyword;
  251. var
  252. tokens: TSyntaxTokenArray;
  253. begin
  254. tokens := DoPascalHighlighting('else');
  255. AssertEquals('Should have 1 token', 1, Length(tokens));
  256. AssertEquals('Token should be ELSE', 'else', tokens[0].Text);
  257. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  258. end;
  259. procedure TTestPascalHighlighter.TestENDKeyword;
  260. var
  261. tokens: TSyntaxTokenArray;
  262. begin
  263. tokens := DoPascalHighlighting('end');
  264. AssertEquals('Should have 1 token', 1, Length(tokens));
  265. AssertEquals('Token should be END', 'end', tokens[0].Text);
  266. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  267. end;
  268. procedure TTestPascalHighlighter.TestEXCEPTKeyword;
  269. var
  270. tokens: TSyntaxTokenArray;
  271. begin
  272. tokens := DoPascalHighlighting('except');
  273. AssertEquals('Should have 1 token', 1, Length(tokens));
  274. AssertEquals('Token should be EXCEPT', 'except', tokens[0].Text);
  275. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  276. end;
  277. procedure TTestPascalHighlighter.TestEXITKeyword;
  278. var
  279. tokens: TSyntaxTokenArray;
  280. begin
  281. tokens := DoPascalHighlighting('exit');
  282. AssertEquals('Should have 1 token', 1, Length(tokens));
  283. AssertEquals('Token should be EXIT', 'exit', tokens[0].Text);
  284. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  285. end;
  286. procedure TTestPascalHighlighter.TestFINALIZATIONKeyword;
  287. var
  288. tokens: TSyntaxTokenArray;
  289. begin
  290. tokens := DoPascalHighlighting('finalization');
  291. AssertEquals('Should have 1 token', 1, Length(tokens));
  292. AssertEquals('Token should be FINALIZATION', 'finalization', tokens[0].Text);
  293. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  294. end;
  295. procedure TTestPascalHighlighter.TestFINALLYKeyword;
  296. var
  297. tokens: TSyntaxTokenArray;
  298. begin
  299. tokens := DoPascalHighlighting('finally');
  300. AssertEquals('Should have 1 token', 1, Length(tokens));
  301. AssertEquals('Token should be FINALLY', 'finally', tokens[0].Text);
  302. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  303. end;
  304. procedure TTestPascalHighlighter.TestFORKeyword;
  305. var
  306. tokens: TSyntaxTokenArray;
  307. begin
  308. tokens := DoPascalHighlighting('for');
  309. AssertEquals('Should have 1 token', 1, Length(tokens));
  310. AssertEquals('Token should be FOR', 'for', tokens[0].Text);
  311. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  312. end;
  313. procedure TTestPascalHighlighter.TestFUNCTIONKeyword;
  314. var
  315. tokens: TSyntaxTokenArray;
  316. begin
  317. tokens := DoPascalHighlighting('function');
  318. AssertEquals('Should have 1 token', 1, Length(tokens));
  319. AssertEquals('Token should be FUNCTION', 'function', tokens[0].Text);
  320. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  321. end;
  322. procedure TTestPascalHighlighter.TestGOTOKeyword;
  323. var
  324. tokens: TSyntaxTokenArray;
  325. begin
  326. tokens := DoPascalHighlighting('goto');
  327. AssertEquals('Should have 1 token', 1, Length(tokens));
  328. AssertEquals('Token should be GOTO', 'goto', tokens[0].Text);
  329. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  330. end;
  331. procedure TTestPascalHighlighter.TestIFKeyword;
  332. var
  333. tokens: TSyntaxTokenArray;
  334. begin
  335. tokens := DoPascalHighlighting('if');
  336. AssertEquals('Should have 1 token', 1, Length(tokens));
  337. AssertEquals('Token should be IF', 'if', tokens[0].Text);
  338. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  339. end;
  340. procedure TTestPascalHighlighter.TestIMPLEMENTATIONKeyword;
  341. var
  342. tokens: TSyntaxTokenArray;
  343. begin
  344. tokens := DoPascalHighlighting('implementation');
  345. AssertEquals('Should have 1 token', 1, Length(tokens));
  346. AssertEquals('Token should be IMPLEMENTATION', 'implementation', tokens[0].Text);
  347. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  348. end;
  349. procedure TTestPascalHighlighter.TestINKeyword;
  350. var
  351. tokens: TSyntaxTokenArray;
  352. begin
  353. tokens := DoPascalHighlighting('in');
  354. AssertEquals('Should have 1 token', 1, Length(tokens));
  355. AssertEquals('Token should be IN', 'in', tokens[0].Text);
  356. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  357. end;
  358. procedure TTestPascalHighlighter.TestINHERITEDKeyword;
  359. var
  360. tokens: TSyntaxTokenArray;
  361. begin
  362. tokens := DoPascalHighlighting('inherited');
  363. AssertEquals('Should have 1 token', 1, Length(tokens));
  364. AssertEquals('Token should be INHERITED', 'inherited', tokens[0].Text);
  365. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  366. end;
  367. procedure TTestPascalHighlighter.TestINITIALIZATIONKeyword;
  368. var
  369. tokens: TSyntaxTokenArray;
  370. begin
  371. tokens := DoPascalHighlighting('initialization');
  372. AssertEquals('Should have 1 token', 1, Length(tokens));
  373. AssertEquals('Token should be INITIALIZATION', 'initialization', tokens[0].Text);
  374. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  375. end;
  376. procedure TTestPascalHighlighter.TestINTERFACEKeyword;
  377. var
  378. tokens: TSyntaxTokenArray;
  379. begin
  380. tokens := DoPascalHighlighting('interface');
  381. AssertEquals('Should have 1 token', 1, Length(tokens));
  382. AssertEquals('Token should be INTERFACE', 'interface', tokens[0].Text);
  383. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  384. end;
  385. procedure TTestPascalHighlighter.TestNILKeyword;
  386. var
  387. tokens: TSyntaxTokenArray;
  388. begin
  389. tokens := DoPascalHighlighting('nil');
  390. AssertEquals('Should have 1 token', 1, Length(tokens));
  391. AssertEquals('Token should be NIL', 'nil', tokens[0].Text);
  392. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  393. end;
  394. procedure TTestPascalHighlighter.TestNOTKeyword;
  395. var
  396. tokens: TSyntaxTokenArray;
  397. begin
  398. tokens := DoPascalHighlighting('not');
  399. AssertEquals('Should have 1 token', 1, Length(tokens));
  400. AssertEquals('Token should be NOT', 'not', tokens[0].Text);
  401. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  402. end;
  403. procedure TTestPascalHighlighter.TestOBJECTKeyword;
  404. var
  405. tokens: TSyntaxTokenArray;
  406. begin
  407. tokens := DoPascalHighlighting('object');
  408. AssertEquals('Should have 1 token', 1, Length(tokens));
  409. AssertEquals('Token should be OBJECT', 'object', tokens[0].Text);
  410. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  411. end;
  412. procedure TTestPascalHighlighter.TestOFKeyword;
  413. var
  414. tokens: TSyntaxTokenArray;
  415. begin
  416. tokens := DoPascalHighlighting('of');
  417. AssertEquals('Should have 1 token', 1, Length(tokens));
  418. AssertEquals('Token should be OF', 'of', tokens[0].Text);
  419. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  420. end;
  421. procedure TTestPascalHighlighter.TestONKeyword;
  422. var
  423. tokens: TSyntaxTokenArray;
  424. begin
  425. tokens := DoPascalHighlighting('on');
  426. AssertEquals('Should have 1 token', 1, Length(tokens));
  427. AssertEquals('Token should be ON', 'on', tokens[0].Text);
  428. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  429. end;
  430. procedure TTestPascalHighlighter.TestORKeyword;
  431. var
  432. tokens: TSyntaxTokenArray;
  433. begin
  434. tokens := DoPascalHighlighting('or');
  435. AssertEquals('Should have 1 token', 1, Length(tokens));
  436. AssertEquals('Token should be OR', 'or', tokens[0].Text);
  437. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  438. end;
  439. procedure TTestPascalHighlighter.TestOVERRIDEKeyword;
  440. var
  441. tokens: TSyntaxTokenArray;
  442. begin
  443. tokens := DoPascalHighlighting('override');
  444. AssertEquals('Should have 1 token', 1, Length(tokens));
  445. AssertEquals('Token should be OVERRIDE', 'override', tokens[0].Text);
  446. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  447. end;
  448. procedure TTestPascalHighlighter.TestPACKEDKeyword;
  449. var
  450. tokens: TSyntaxTokenArray;
  451. begin
  452. tokens := DoPascalHighlighting('packed');
  453. AssertEquals('Should have 1 token', 1, Length(tokens));
  454. AssertEquals('Token should be PACKED', 'packed', tokens[0].Text);
  455. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  456. end;
  457. procedure TTestPascalHighlighter.TestPRIVATEKeyword;
  458. var
  459. tokens: TSyntaxTokenArray;
  460. begin
  461. tokens := DoPascalHighlighting('private');
  462. AssertEquals('Should have 1 token', 1, Length(tokens));
  463. AssertEquals('Token should be PRIVATE', 'private', tokens[0].Text);
  464. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  465. end;
  466. procedure TTestPascalHighlighter.TestPROCEDUREKeyword;
  467. var
  468. tokens: TSyntaxTokenArray;
  469. begin
  470. tokens := DoPascalHighlighting('procedure');
  471. AssertEquals('Should have 1 token', 1, Length(tokens));
  472. AssertEquals('Token should be PROCEDURE', 'procedure', tokens[0].Text);
  473. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  474. end;
  475. procedure TTestPascalHighlighter.TestPROGRAMKeyword;
  476. var
  477. tokens: TSyntaxTokenArray;
  478. begin
  479. tokens := DoPascalHighlighting('program');
  480. AssertEquals('Should have 1 token', 1, Length(tokens));
  481. AssertEquals('Token should be PROGRAM', 'program', tokens[0].Text);
  482. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  483. end;
  484. procedure TTestPascalHighlighter.TestPROPERTYKeyword;
  485. var
  486. tokens: TSyntaxTokenArray;
  487. begin
  488. tokens := DoPascalHighlighting('property');
  489. AssertEquals('Should have 1 token', 1, Length(tokens));
  490. AssertEquals('Token should be PROPERTY', 'property', tokens[0].Text);
  491. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  492. end;
  493. procedure TTestPascalHighlighter.TestPROTECTEDKeyword;
  494. var
  495. tokens: TSyntaxTokenArray;
  496. begin
  497. tokens := DoPascalHighlighting('protected');
  498. AssertEquals('Should have 1 token', 1, Length(tokens));
  499. AssertEquals('Token should be PROTECTED', 'protected', tokens[0].Text);
  500. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  501. end;
  502. procedure TTestPascalHighlighter.TestPUBLICKeyword;
  503. var
  504. tokens: TSyntaxTokenArray;
  505. begin
  506. tokens := DoPascalHighlighting('public');
  507. AssertEquals('Should have 1 token', 1, Length(tokens));
  508. AssertEquals('Token should be PUBLIC', 'public', tokens[0].Text);
  509. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  510. end;
  511. procedure TTestPascalHighlighter.TestPUBLISHEDKeyword;
  512. var
  513. tokens: TSyntaxTokenArray;
  514. begin
  515. tokens := DoPascalHighlighting('published');
  516. AssertEquals('Should have 1 token', 1, Length(tokens));
  517. AssertEquals('Token should be PUBLISHED', 'published', tokens[0].Text);
  518. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  519. end;
  520. procedure TTestPascalHighlighter.TestRAISEKeyword;
  521. var
  522. tokens: TSyntaxTokenArray;
  523. begin
  524. tokens := DoPascalHighlighting('raise');
  525. AssertEquals('Should have 1 token', 1, Length(tokens));
  526. AssertEquals('Token should be RAISE', 'raise', tokens[0].Text);
  527. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  528. end;
  529. procedure TTestPascalHighlighter.TestRECORDKeyword;
  530. var
  531. tokens: TSyntaxTokenArray;
  532. begin
  533. tokens := DoPascalHighlighting('record');
  534. AssertEquals('Should have 1 token', 1, Length(tokens));
  535. AssertEquals('Token should be RECORD', 'record', tokens[0].Text);
  536. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  537. end;
  538. procedure TTestPascalHighlighter.TestREPEATKeyword;
  539. var
  540. tokens: TSyntaxTokenArray;
  541. begin
  542. tokens := DoPascalHighlighting('repeat');
  543. AssertEquals('Should have 1 token', 1, Length(tokens));
  544. AssertEquals('Token should be REPEAT', 'repeat', tokens[0].Text);
  545. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  546. end;
  547. procedure TTestPascalHighlighter.TestRESOURCESTRINGKeyword;
  548. var
  549. tokens: TSyntaxTokenArray;
  550. begin
  551. tokens := DoPascalHighlighting('resourcestring');
  552. AssertEquals('Should have 1 token', 1, Length(tokens));
  553. AssertEquals('Token should be RESOURCESTRING', 'resourcestring', tokens[0].Text);
  554. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  555. end;
  556. procedure TTestPascalHighlighter.TestSETKeyword;
  557. var
  558. tokens: TSyntaxTokenArray;
  559. begin
  560. tokens := DoPascalHighlighting('set');
  561. AssertEquals('Should have 1 token', 1, Length(tokens));
  562. AssertEquals('Token should be SET', 'set', tokens[0].Text);
  563. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  564. end;
  565. procedure TTestPascalHighlighter.TestTHENKeyword;
  566. var
  567. tokens: TSyntaxTokenArray;
  568. begin
  569. tokens := DoPascalHighlighting('then');
  570. AssertEquals('Should have 1 token', 1, Length(tokens));
  571. AssertEquals('Token should be THEN', 'then', tokens[0].Text);
  572. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  573. end;
  574. procedure TTestPascalHighlighter.TestTRYKeyword;
  575. var
  576. tokens: TSyntaxTokenArray;
  577. begin
  578. tokens := DoPascalHighlighting('try');
  579. AssertEquals('Should have 1 token', 1, Length(tokens));
  580. AssertEquals('Token should be TRY', 'try', tokens[0].Text);
  581. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  582. end;
  583. procedure TTestPascalHighlighter.TestTYPEKeyword;
  584. var
  585. tokens: TSyntaxTokenArray;
  586. begin
  587. tokens := DoPascalHighlighting('type');
  588. AssertEquals('Should have 1 token', 1, Length(tokens));
  589. AssertEquals('Token should be TYPE', 'type', tokens[0].Text);
  590. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  591. end;
  592. procedure TTestPascalHighlighter.TestUNITKeyword;
  593. var
  594. tokens: TSyntaxTokenArray;
  595. begin
  596. tokens := DoPascalHighlighting('unit');
  597. AssertEquals('Should have 1 token', 1, Length(tokens));
  598. AssertEquals('Token should be UNIT', 'unit', tokens[0].Text);
  599. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  600. end;
  601. procedure TTestPascalHighlighter.TestUNTILKeyword;
  602. var
  603. tokens: TSyntaxTokenArray;
  604. begin
  605. tokens := DoPascalHighlighting('until');
  606. AssertEquals('Should have 1 token', 1, Length(tokens));
  607. AssertEquals('Token should be UNTIL', 'until', tokens[0].Text);
  608. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  609. end;
  610. procedure TTestPascalHighlighter.TestUSESKeyword;
  611. var
  612. tokens: TSyntaxTokenArray;
  613. begin
  614. tokens := DoPascalHighlighting('uses');
  615. AssertEquals('Should have 1 token', 1, Length(tokens));
  616. AssertEquals('Token should be USES', 'uses', tokens[0].Text);
  617. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  618. end;
  619. procedure TTestPascalHighlighter.TestVARKeyword;
  620. var
  621. tokens: TSyntaxTokenArray;
  622. begin
  623. tokens := DoPascalHighlighting('var');
  624. AssertEquals('Should have 1 token', 1, Length(tokens));
  625. AssertEquals('Token should be VAR', 'var', tokens[0].Text);
  626. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  627. end;
  628. procedure TTestPascalHighlighter.TestVIRTUALKeyword;
  629. var
  630. tokens: TSyntaxTokenArray;
  631. begin
  632. tokens := DoPascalHighlighting('virtual');
  633. AssertEquals('Should have 1 token', 1, Length(tokens));
  634. AssertEquals('Token should be VIRTUAL', 'virtual', tokens[0].Text);
  635. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  636. end;
  637. procedure TTestPascalHighlighter.TestWHILEKeyword;
  638. var
  639. tokens: TSyntaxTokenArray;
  640. begin
  641. tokens := DoPascalHighlighting('while');
  642. AssertEquals('Should have 1 token', 1, Length(tokens));
  643. AssertEquals('Token should be WHILE', 'while', tokens[0].Text);
  644. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  645. end;
  646. procedure TTestPascalHighlighter.TestWITHKeyword;
  647. var
  648. tokens: TSyntaxTokenArray;
  649. begin
  650. tokens := DoPascalHighlighting('with');
  651. AssertEquals('Should have 1 token', 1, Length(tokens));
  652. AssertEquals('Token should be WITH', 'with', tokens[0].Text);
  653. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  654. end;
  655. procedure TTestPascalHighlighter.TestXORKeyword;
  656. var
  657. tokens: TSyntaxTokenArray;
  658. begin
  659. tokens := DoPascalHighlighting('xor');
  660. AssertEquals('Should have 1 token', 1, Length(tokens));
  661. AssertEquals('Token should be XOR', 'xor', tokens[0].Text);
  662. AssertEquals('Token should be keyword', Ord(shKeyword), Ord(tokens[0].Kind));
  663. end;
  664. procedure TTestPascalHighlighter.TestComments;
  665. var
  666. tokens: TSyntaxTokenArray;
  667. begin
  668. // Test { } comment
  669. tokens := DoPascalHighlighting('{ this is a comment }');
  670. AssertEquals('Should have 1 token', 1, Length(tokens));
  671. AssertEquals('Token should be comment text', '{ this is a comment }', tokens[0].Text);
  672. AssertEquals('Token should be comment', Ord(shComment), Ord(tokens[0].Kind));
  673. // Test (* *) comment
  674. tokens := DoPascalHighlighting('(* this is a comment *)');
  675. AssertEquals('Should have 1 token', 1, Length(tokens));
  676. AssertEquals('Token should be comment text', '(* this is a comment *)', tokens[0].Text);
  677. AssertEquals('Token should be comment', Ord(shComment), Ord(tokens[0].Kind));
  678. // Test // comment
  679. tokens := DoPascalHighlighting('// this is a comment');
  680. AssertEquals('Should have 1 token', 1, Length(tokens));
  681. AssertEquals('Token should be comment text', '// this is a comment', tokens[0].Text);
  682. AssertEquals('Token should be comment', Ord(shComment), Ord(tokens[0].Kind));
  683. end;
  684. procedure TTestPascalHighlighter.TestStrings;
  685. var
  686. tokens: TSyntaxTokenArray;
  687. begin
  688. tokens := DoPascalHighlighting('''Hello World''');
  689. AssertEquals('Should have 1 token', 1, Length(tokens));
  690. AssertEquals('Token should be string', '''Hello World''', tokens[0].Text);
  691. AssertEquals('Token should be string type', Ord(shStrings), Ord(tokens[0].Kind));
  692. // Test character literal
  693. tokens := DoPascalHighlighting('''A''');
  694. AssertEquals('Should have 1 token', 1, Length(tokens));
  695. AssertEquals('Token should be char', '''A''', tokens[0].Text);
  696. AssertEquals('Token should be character type', Ord(shCharacters), Ord(tokens[0].Kind));
  697. end;
  698. procedure TTestPascalHighlighter.TestNumbers;
  699. var
  700. tokens: TSyntaxTokenArray;
  701. begin
  702. // Test decimal number
  703. tokens := DoPascalHighlighting('123');
  704. AssertEquals('Should have 1 token', 1, Length(tokens));
  705. AssertEquals('Token should be number', '123', tokens[0].Text);
  706. AssertEquals('Token should be number type', Ord(shNumbers), Ord(tokens[0].Kind));
  707. // Test hex number
  708. tokens := DoPascalHighlighting('$FF');
  709. AssertEquals('Should have 1 token', 1, Length(tokens));
  710. AssertEquals('Token should be hex number', '$FF', tokens[0].Text);
  711. AssertEquals('Token should be number type', Ord(shNumbers), Ord(tokens[0].Kind));
  712. end;
  713. procedure TTestPascalHighlighter.TestSymbols;
  714. var
  715. tokens: TSyntaxTokenArray;
  716. begin
  717. tokens := DoPascalHighlighting(':=');
  718. AssertEquals('Should have 1 token', 1, Length(tokens));
  719. AssertEquals('Token should be assignment', ':=', tokens[0].Text);
  720. AssertEquals('Token should be symbol type', Ord(shSymbol), Ord(tokens[0].Kind));
  721. tokens := DoPascalHighlighting(';');
  722. AssertEquals('Should have 1 token', 1, Length(tokens));
  723. AssertEquals('Token should be semicolon', ';', tokens[0].Text);
  724. AssertEquals('Token should be symbol type', Ord(shSymbol), Ord(tokens[0].Kind));
  725. end;
  726. procedure TTestPascalHighlighter.TestDirectives;
  727. var
  728. tokens: TSyntaxTokenArray;
  729. begin
  730. tokens := DoPascalHighlighting('{$MODE OBJFPC}');
  731. AssertEquals('Should have 1 token', 1, Length(tokens));
  732. AssertEquals('Token should be directive', '{$MODE OBJFPC}', tokens[0].Text);
  733. AssertEquals('Token should be directive type', Ord(shDirective), Ord(tokens[0].Kind));
  734. end;
  735. procedure TTestPascalHighlighter.TestIdentifiers;
  736. var
  737. tokens: TSyntaxTokenArray;
  738. begin
  739. tokens := DoPascalHighlighting('MyVariable');
  740. AssertEquals('Should have 1 token', 1, Length(tokens));
  741. AssertEquals('Token should be identifier', 'MyVariable', tokens[0].Text);
  742. AssertEquals('Token should be default type', Ord(shDefault), Ord(tokens[0].Kind));
  743. end;
  744. initialization
  745. RegisterTest(TTestPascalHighlighter);
  746. end.