1
0

Helios-Commands-SUnit.js 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620
  1. define(["amber/boot", "require", "helios/Helios-Commands-Tools"], function($boot,requirejs){"use strict";
  2. var $core=$boot.api,nil=$boot.nilAsValue,$nil=$boot.nilAsReceiver,$recv=$boot.asReceiver,$globals=$boot.globals;
  3. var $pkg = $core.addPackage("Helios-Commands-SUnit");
  4. $pkg.transport = {"type":"amd","amdNamespace":"helios"};
  5. $core.addClass("HLSUnitCommand", $globals.HLToolCommand, "Helios-Commands-SUnit");
  6. //>>excludeStart("ide", pragmas.excludeIdeData);
  7. $globals.HLSUnitCommand.comment="I group the commands pertaining to Helios-SUnit (`HLSUnitModel`)";
  8. //>>excludeEnd("ide");
  9. $core.addMethod(
  10. $core.method({
  11. selector: "isValidFor:",
  12. protocol: "testing",
  13. //>>excludeStart("ide", pragmas.excludeIdeData);
  14. args: ["aModel"],
  15. source: "isValidFor: aModel\x0a\x09^ aModel isKindOf: HLSUnitModel",
  16. referencedClasses: ["HLSUnitModel"],
  17. //>>excludeEnd("ide");
  18. pragmas: [],
  19. messageSends: ["isKindOf:"]
  20. }, function ($methodClass){ return function (aModel){
  21. var self=this,$self=this;
  22. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  23. return $core.withContext(function($ctx1) {
  24. //>>excludeEnd("ctx");
  25. return $recv(aModel)._isKindOf_($globals.HLSUnitModel);
  26. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  27. }, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel})});
  28. //>>excludeEnd("ctx");
  29. }; }),
  30. $globals.HLSUnitCommand.a$cls);
  31. $core.addClass("HLSUnitInvertSelectedCommand", $globals.HLSUnitCommand, "Helios-Commands-SUnit");
  32. //>>excludeStart("ide", pragmas.excludeIdeData);
  33. $globals.HLSUnitInvertSelectedCommand.comment="I group the commands that invert selections";
  34. //>>excludeEnd("ide");
  35. $core.addMethod(
  36. $core.method({
  37. selector: "key",
  38. protocol: "accessing",
  39. //>>excludeStart("ide", pragmas.excludeIdeData);
  40. args: [],
  41. source: "key\x0a\x09^ 'i'",
  42. referencedClasses: [],
  43. //>>excludeEnd("ide");
  44. pragmas: [],
  45. messageSends: []
  46. }, function ($methodClass){ return function (){
  47. var self=this,$self=this;
  48. return "i";
  49. }; }),
  50. $globals.HLSUnitInvertSelectedCommand.a$cls);
  51. $core.addMethod(
  52. $core.method({
  53. selector: "label",
  54. protocol: "accessing",
  55. //>>excludeStart("ide", pragmas.excludeIdeData);
  56. args: [],
  57. source: "label\x0a\x09^'Invert selection'",
  58. referencedClasses: [],
  59. //>>excludeEnd("ide");
  60. pragmas: [],
  61. messageSends: []
  62. }, function ($methodClass){ return function (){
  63. var self=this,$self=this;
  64. return "Invert selection";
  65. }; }),
  66. $globals.HLSUnitInvertSelectedCommand.a$cls);
  67. $core.addClass("HLSUnitInvertSelectedClassesCommand", $globals.HLSUnitInvertSelectedCommand, "Helios-Commands-SUnit");
  68. //>>excludeStart("ide", pragmas.excludeIdeData);
  69. $globals.HLSUnitInvertSelectedClassesCommand.comment="Invert the currently selected classes on a `HLSUnitModel`";
  70. //>>excludeEnd("ide");
  71. $core.addMethod(
  72. $core.method({
  73. selector: "category",
  74. protocol: "accessing",
  75. //>>excludeStart("ide", pragmas.excludeIdeData);
  76. args: [],
  77. source: "category\x0a\x09^'Classes'",
  78. referencedClasses: [],
  79. //>>excludeEnd("ide");
  80. pragmas: [],
  81. messageSends: []
  82. }, function ($methodClass){ return function (){
  83. var self=this,$self=this;
  84. return "Classes";
  85. }; }),
  86. $globals.HLSUnitInvertSelectedClassesCommand);
  87. $core.addMethod(
  88. $core.method({
  89. selector: "execute",
  90. protocol: "executing",
  91. //>>excludeStart("ide", pragmas.excludeIdeData);
  92. args: [],
  93. source: "execute\x0a\x09self model invertSelectedClasses",
  94. referencedClasses: [],
  95. //>>excludeEnd("ide");
  96. pragmas: [],
  97. messageSends: ["invertSelectedClasses", "model"]
  98. }, function ($methodClass){ return function (){
  99. var self=this,$self=this;
  100. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  101. return $core.withContext(function($ctx1) {
  102. //>>excludeEnd("ctx");
  103. $recv($self._model())._invertSelectedClasses();
  104. return self;
  105. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  106. }, function($ctx1) {$ctx1.fill(self,"execute",{})});
  107. //>>excludeEnd("ctx");
  108. }; }),
  109. $globals.HLSUnitInvertSelectedClassesCommand);
  110. $core.addMethod(
  111. $core.method({
  112. selector: "isActive",
  113. protocol: "testing",
  114. //>>excludeStart("ide", pragmas.excludeIdeData);
  115. args: [],
  116. source: "isActive\x0a\x09^model selectedPackages notEmpty",
  117. referencedClasses: [],
  118. //>>excludeEnd("ide");
  119. pragmas: [],
  120. messageSends: ["notEmpty", "selectedPackages"]
  121. }, function ($methodClass){ return function (){
  122. var self=this,$self=this;
  123. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  124. return $core.withContext(function($ctx1) {
  125. //>>excludeEnd("ctx");
  126. return $recv($recv($self.model)._selectedPackages())._notEmpty();
  127. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  128. }, function($ctx1) {$ctx1.fill(self,"isActive",{})});
  129. //>>excludeEnd("ctx");
  130. }; }),
  131. $globals.HLSUnitInvertSelectedClassesCommand);
  132. $core.addMethod(
  133. $core.method({
  134. selector: "key",
  135. protocol: "accessing",
  136. //>>excludeStart("ide", pragmas.excludeIdeData);
  137. args: [],
  138. source: "key\x0a\x09^ 'c'",
  139. referencedClasses: [],
  140. //>>excludeEnd("ide");
  141. pragmas: [],
  142. messageSends: []
  143. }, function ($methodClass){ return function (){
  144. var self=this,$self=this;
  145. return "c";
  146. }; }),
  147. $globals.HLSUnitInvertSelectedClassesCommand.a$cls);
  148. $core.addMethod(
  149. $core.method({
  150. selector: "label",
  151. protocol: "accessing",
  152. //>>excludeStart("ide", pragmas.excludeIdeData);
  153. args: [],
  154. source: "label\x0a\x09^ 'Invert selected classes'",
  155. referencedClasses: [],
  156. //>>excludeEnd("ide");
  157. pragmas: [],
  158. messageSends: []
  159. }, function ($methodClass){ return function (){
  160. var self=this,$self=this;
  161. return "Invert selected classes";
  162. }; }),
  163. $globals.HLSUnitInvertSelectedClassesCommand.a$cls);
  164. $core.addClass("HLSUnitInvertSelectedPackagesCommand", $globals.HLSUnitInvertSelectedCommand, "Helios-Commands-SUnit");
  165. //>>excludeStart("ide", pragmas.excludeIdeData);
  166. $globals.HLSUnitInvertSelectedPackagesCommand.comment="Invert the currently selected packages on a `HLSUnitModel`";
  167. //>>excludeEnd("ide");
  168. $core.addMethod(
  169. $core.method({
  170. selector: "category",
  171. protocol: "accessing",
  172. //>>excludeStart("ide", pragmas.excludeIdeData);
  173. args: [],
  174. source: "category\x0a\x09^'Packages'",
  175. referencedClasses: [],
  176. //>>excludeEnd("ide");
  177. pragmas: [],
  178. messageSends: []
  179. }, function ($methodClass){ return function (){
  180. var self=this,$self=this;
  181. return "Packages";
  182. }; }),
  183. $globals.HLSUnitInvertSelectedPackagesCommand);
  184. $core.addMethod(
  185. $core.method({
  186. selector: "execute",
  187. protocol: "executing",
  188. //>>excludeStart("ide", pragmas.excludeIdeData);
  189. args: [],
  190. source: "execute\x0a\x09self model invertSelectedPackages",
  191. referencedClasses: [],
  192. //>>excludeEnd("ide");
  193. pragmas: [],
  194. messageSends: ["invertSelectedPackages", "model"]
  195. }, function ($methodClass){ return function (){
  196. var self=this,$self=this;
  197. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  198. return $core.withContext(function($ctx1) {
  199. //>>excludeEnd("ctx");
  200. $recv($self._model())._invertSelectedPackages();
  201. return self;
  202. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  203. }, function($ctx1) {$ctx1.fill(self,"execute",{})});
  204. //>>excludeEnd("ctx");
  205. }; }),
  206. $globals.HLSUnitInvertSelectedPackagesCommand);
  207. $core.addMethod(
  208. $core.method({
  209. selector: "isActive",
  210. protocol: "testing",
  211. //>>excludeStart("ide", pragmas.excludeIdeData);
  212. args: [],
  213. source: "isActive\x0a\x09^true",
  214. referencedClasses: [],
  215. //>>excludeEnd("ide");
  216. pragmas: [],
  217. messageSends: []
  218. }, function ($methodClass){ return function (){
  219. var self=this,$self=this;
  220. return true;
  221. }; }),
  222. $globals.HLSUnitInvertSelectedPackagesCommand);
  223. $core.addMethod(
  224. $core.method({
  225. selector: "key",
  226. protocol: "accessing",
  227. //>>excludeStart("ide", pragmas.excludeIdeData);
  228. args: [],
  229. source: "key\x0a\x09^ 'p'",
  230. referencedClasses: [],
  231. //>>excludeEnd("ide");
  232. pragmas: [],
  233. messageSends: []
  234. }, function ($methodClass){ return function (){
  235. var self=this,$self=this;
  236. return "p";
  237. }; }),
  238. $globals.HLSUnitInvertSelectedPackagesCommand.a$cls);
  239. $core.addMethod(
  240. $core.method({
  241. selector: "label",
  242. protocol: "accessing",
  243. //>>excludeStart("ide", pragmas.excludeIdeData);
  244. args: [],
  245. source: "label\x0a\x09^ 'Invert selected packages'",
  246. referencedClasses: [],
  247. //>>excludeEnd("ide");
  248. pragmas: [],
  249. messageSends: []
  250. }, function ($methodClass){ return function (){
  251. var self=this,$self=this;
  252. return "Invert selected packages";
  253. }; }),
  254. $globals.HLSUnitInvertSelectedPackagesCommand.a$cls);
  255. $core.addClass("HLSUnitRunTests", $globals.HLSUnitCommand, "Helios-Commands-SUnit");
  256. //>>excludeStart("ide", pragmas.excludeIdeData);
  257. $globals.HLSUnitRunTests.comment="Run the test cases in the currently selected classes on a `HLSUnitModel`";
  258. //>>excludeEnd("ide");
  259. $core.addMethod(
  260. $core.method({
  261. selector: "execute",
  262. protocol: "executing",
  263. //>>excludeStart("ide", pragmas.excludeIdeData);
  264. args: [],
  265. source: "execute\x0a\x09self model runTests",
  266. referencedClasses: [],
  267. //>>excludeEnd("ide");
  268. pragmas: [],
  269. messageSends: ["runTests", "model"]
  270. }, function ($methodClass){ return function (){
  271. var self=this,$self=this;
  272. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  273. return $core.withContext(function($ctx1) {
  274. //>>excludeEnd("ctx");
  275. $recv($self._model())._runTests();
  276. return self;
  277. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  278. }, function($ctx1) {$ctx1.fill(self,"execute",{})});
  279. //>>excludeEnd("ctx");
  280. }; }),
  281. $globals.HLSUnitRunTests);
  282. $core.addMethod(
  283. $core.method({
  284. selector: "isActive",
  285. protocol: "testing",
  286. //>>excludeStart("ide", pragmas.excludeIdeData);
  287. args: [],
  288. source: "isActive\x0a\x09^true",
  289. referencedClasses: [],
  290. //>>excludeEnd("ide");
  291. pragmas: [],
  292. messageSends: []
  293. }, function ($methodClass){ return function (){
  294. var self=this,$self=this;
  295. return true;
  296. }; }),
  297. $globals.HLSUnitRunTests);
  298. $core.addMethod(
  299. $core.method({
  300. selector: "key",
  301. protocol: "accessing",
  302. //>>excludeStart("ide", pragmas.excludeIdeData);
  303. args: [],
  304. source: "key\x0a\x09^'r'",
  305. referencedClasses: [],
  306. //>>excludeEnd("ide");
  307. pragmas: [],
  308. messageSends: []
  309. }, function ($methodClass){ return function (){
  310. var self=this,$self=this;
  311. return "r";
  312. }; }),
  313. $globals.HLSUnitRunTests.a$cls);
  314. $core.addMethod(
  315. $core.method({
  316. selector: "label",
  317. protocol: "accessing",
  318. //>>excludeStart("ide", pragmas.excludeIdeData);
  319. args: [],
  320. source: "label\x0a\x09^'Run Tests'",
  321. referencedClasses: [],
  322. //>>excludeEnd("ide");
  323. pragmas: [],
  324. messageSends: []
  325. }, function ($methodClass){ return function (){
  326. var self=this,$self=this;
  327. return "Run Tests";
  328. }; }),
  329. $globals.HLSUnitRunTests.a$cls);
  330. $core.addClass("HLSUnitSelectAllCommand", $globals.HLSUnitCommand, "Helios-Commands-SUnit");
  331. //>>excludeStart("ide", pragmas.excludeIdeData);
  332. $globals.HLSUnitSelectAllCommand.comment="I group the select all commands";
  333. //>>excludeEnd("ide");
  334. $core.addMethod(
  335. $core.method({
  336. selector: "key",
  337. protocol: "accessing",
  338. //>>excludeStart("ide", pragmas.excludeIdeData);
  339. args: [],
  340. source: "key\x0a\x09^ 'a'",
  341. referencedClasses: [],
  342. //>>excludeEnd("ide");
  343. pragmas: [],
  344. messageSends: []
  345. }, function ($methodClass){ return function (){
  346. var self=this,$self=this;
  347. return "a";
  348. }; }),
  349. $globals.HLSUnitSelectAllCommand.a$cls);
  350. $core.addMethod(
  351. $core.method({
  352. selector: "label",
  353. protocol: "accessing",
  354. //>>excludeStart("ide", pragmas.excludeIdeData);
  355. args: [],
  356. source: "label\x0a\x09^ 'Select all'",
  357. referencedClasses: [],
  358. //>>excludeEnd("ide");
  359. pragmas: [],
  360. messageSends: []
  361. }, function ($methodClass){ return function (){
  362. var self=this,$self=this;
  363. return "Select all";
  364. }; }),
  365. $globals.HLSUnitSelectAllCommand.a$cls);
  366. $core.addClass("HLSUnitSelectAllClassesCommand", $globals.HLSUnitSelectAllCommand, "Helios-Commands-SUnit");
  367. //>>excludeStart("ide", pragmas.excludeIdeData);
  368. $globals.HLSUnitSelectAllClassesCommand.comment="Select all available test classes based on what packages are selected on a `HLSUnitModel`";
  369. //>>excludeEnd("ide");
  370. $core.addMethod(
  371. $core.method({
  372. selector: "category",
  373. protocol: "accessing",
  374. //>>excludeStart("ide", pragmas.excludeIdeData);
  375. args: [],
  376. source: "category\x0a\x09^'Classes'",
  377. referencedClasses: [],
  378. //>>excludeEnd("ide");
  379. pragmas: [],
  380. messageSends: []
  381. }, function ($methodClass){ return function (){
  382. var self=this,$self=this;
  383. return "Classes";
  384. }; }),
  385. $globals.HLSUnitSelectAllClassesCommand);
  386. $core.addMethod(
  387. $core.method({
  388. selector: "execute",
  389. protocol: "executing",
  390. //>>excludeStart("ide", pragmas.excludeIdeData);
  391. args: [],
  392. source: "execute\x0a\x09self model selectAllClasses",
  393. referencedClasses: [],
  394. //>>excludeEnd("ide");
  395. pragmas: [],
  396. messageSends: ["selectAllClasses", "model"]
  397. }, function ($methodClass){ return function (){
  398. var self=this,$self=this;
  399. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  400. return $core.withContext(function($ctx1) {
  401. //>>excludeEnd("ctx");
  402. $recv($self._model())._selectAllClasses();
  403. return self;
  404. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  405. }, function($ctx1) {$ctx1.fill(self,"execute",{})});
  406. //>>excludeEnd("ctx");
  407. }; }),
  408. $globals.HLSUnitSelectAllClassesCommand);
  409. $core.addMethod(
  410. $core.method({
  411. selector: "isActive",
  412. protocol: "testing",
  413. //>>excludeStart("ide", pragmas.excludeIdeData);
  414. args: [],
  415. source: "isActive\x0a\x09^model selectedPackages notEmpty",
  416. referencedClasses: [],
  417. //>>excludeEnd("ide");
  418. pragmas: [],
  419. messageSends: ["notEmpty", "selectedPackages"]
  420. }, function ($methodClass){ return function (){
  421. var self=this,$self=this;
  422. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  423. return $core.withContext(function($ctx1) {
  424. //>>excludeEnd("ctx");
  425. return $recv($recv($self.model)._selectedPackages())._notEmpty();
  426. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  427. }, function($ctx1) {$ctx1.fill(self,"isActive",{})});
  428. //>>excludeEnd("ctx");
  429. }; }),
  430. $globals.HLSUnitSelectAllClassesCommand);
  431. $core.addMethod(
  432. $core.method({
  433. selector: "key",
  434. protocol: "accessing",
  435. //>>excludeStart("ide", pragmas.excludeIdeData);
  436. args: [],
  437. source: "key\x0a\x09^ 'c'",
  438. referencedClasses: [],
  439. //>>excludeEnd("ide");
  440. pragmas: [],
  441. messageSends: []
  442. }, function ($methodClass){ return function (){
  443. var self=this,$self=this;
  444. return "c";
  445. }; }),
  446. $globals.HLSUnitSelectAllClassesCommand.a$cls);
  447. $core.addMethod(
  448. $core.method({
  449. selector: "label",
  450. protocol: "accessing",
  451. //>>excludeStart("ide", pragmas.excludeIdeData);
  452. args: [],
  453. source: "label\x0a\x09^ 'Select all classes'",
  454. referencedClasses: [],
  455. //>>excludeEnd("ide");
  456. pragmas: [],
  457. messageSends: []
  458. }, function ($methodClass){ return function (){
  459. var self=this,$self=this;
  460. return "Select all classes";
  461. }; }),
  462. $globals.HLSUnitSelectAllClassesCommand.a$cls);
  463. $core.addClass("HLSUnitSelectAllPackagesCommand", $globals.HLSUnitSelectAllCommand, "Helios-Commands-SUnit");
  464. //>>excludeStart("ide", pragmas.excludeIdeData);
  465. $globals.HLSUnitSelectAllPackagesCommand.comment="Select all packages with test cases on a `HLSUnitModel`";
  466. //>>excludeEnd("ide");
  467. $core.addMethod(
  468. $core.method({
  469. selector: "category",
  470. protocol: "accessing",
  471. //>>excludeStart("ide", pragmas.excludeIdeData);
  472. args: [],
  473. source: "category\x0a\x09^'Packages'",
  474. referencedClasses: [],
  475. //>>excludeEnd("ide");
  476. pragmas: [],
  477. messageSends: []
  478. }, function ($methodClass){ return function (){
  479. var self=this,$self=this;
  480. return "Packages";
  481. }; }),
  482. $globals.HLSUnitSelectAllPackagesCommand);
  483. $core.addMethod(
  484. $core.method({
  485. selector: "execute",
  486. protocol: "executing",
  487. //>>excludeStart("ide", pragmas.excludeIdeData);
  488. args: [],
  489. source: "execute\x0a\x09self model selectAllPackages",
  490. referencedClasses: [],
  491. //>>excludeEnd("ide");
  492. pragmas: [],
  493. messageSends: ["selectAllPackages", "model"]
  494. }, function ($methodClass){ return function (){
  495. var self=this,$self=this;
  496. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  497. return $core.withContext(function($ctx1) {
  498. //>>excludeEnd("ctx");
  499. $recv($self._model())._selectAllPackages();
  500. return self;
  501. //>>excludeStart("ctx", pragmas.excludeDebugContexts);
  502. }, function($ctx1) {$ctx1.fill(self,"execute",{})});
  503. //>>excludeEnd("ctx");
  504. }; }),
  505. $globals.HLSUnitSelectAllPackagesCommand);
  506. $core.addMethod(
  507. $core.method({
  508. selector: "isActive",
  509. protocol: "testing",
  510. //>>excludeStart("ide", pragmas.excludeIdeData);
  511. args: [],
  512. source: "isActive\x0a\x09^true",
  513. referencedClasses: [],
  514. //>>excludeEnd("ide");
  515. pragmas: [],
  516. messageSends: []
  517. }, function ($methodClass){ return function (){
  518. var self=this,$self=this;
  519. return true;
  520. }; }),
  521. $globals.HLSUnitSelectAllPackagesCommand);
  522. $core.addMethod(
  523. $core.method({
  524. selector: "key",
  525. protocol: "accessing",
  526. //>>excludeStart("ide", pragmas.excludeIdeData);
  527. args: [],
  528. source: "key\x0a\x09^ 'p'",
  529. referencedClasses: [],
  530. //>>excludeEnd("ide");
  531. pragmas: [],
  532. messageSends: []
  533. }, function ($methodClass){ return function (){
  534. var self=this,$self=this;
  535. return "p";
  536. }; }),
  537. $globals.HLSUnitSelectAllPackagesCommand.a$cls);
  538. $core.addMethod(
  539. $core.method({
  540. selector: "label",
  541. protocol: "accessing",
  542. //>>excludeStart("ide", pragmas.excludeIdeData);
  543. args: [],
  544. source: "label\x0a\x09^ 'Select all packages'",
  545. referencedClasses: [],
  546. //>>excludeEnd("ide");
  547. pragmas: [],
  548. messageSends: []
  549. }, function ($methodClass){ return function (){
  550. var self=this,$self=this;
  551. return "Select all packages";
  552. }; }),
  553. $globals.HLSUnitSelectAllPackagesCommand.a$cls);
  554. });