/tests/message.rb

https://bitbucket.org/tagoh/prune · Ruby · 7903 lines · 6537 code · 1038 blank · 328 comment · 186 complexity · c9b726722867aea9f54621dc14353ca4 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. # message.rb
    2. 

  2. # Copyright (C) 2009 Akira TAGOH
    3. 

  3. 

  4. # Authors:
    5. 

  5. #   Akira TAGOH  <akira@tagoh.org>
    6. 

  6. 

  7. # This program is free software; you can redistribute it and/or modify
    8. 

  8. # it under the terms of the GNU General Public License as published by
    9. 

  9. # the Free Software Foundation; either version 2 of the License, or
    10. 

  10. # (at your option) any later version.
    11. 

  11. 

  12. # This program is distributed in the hope that it will be useful,
    13. 

  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
    14. 

  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15. 

  15. # GNU General Public License for more details.
    16. 

  16. 

  17. # You should have received a copy of the GNU General Public License
    18. 

  18. # along with this program; if not, write to the Free Software
    19. 

  19. # Foundation, Inc., 59 Temple Place - Suite 330,
    20. 

  20. # Boston, MA 02111-1307, USA.
    21. 

  21. 

  22. require 'rubygems'
    23. 

  23. gem 'test-unit'
    24. 

  24. require 'test/unit/testcase'
    25. 

  25. require 'prune/message'
    26. 

  26. 

  27. class TestPRUNE__MessageHandler < Test::Unit::TestCase
    28. 

  28. 

  29.   def setup
    30. 

  30.     @t = PRUNE::MessageHandler.instance
    31. 

  31.   end # def setup
    32. 

  32. 

  33.   def teardown
    34. 

  34.     
    35. 

  35.   end # def teardown
    36. 

  36. 

  37.   def test_new
    38. 

  38.     assert_nothing_raised {@t.new({
    39. 

  39.                                   :prefix=>{
    40. 

  40.                                     :nick=>'foo',
    41. 

  41.                                     :user=>'foo',
    42. 

  42.                                     :host=>'example.com'},
    43. 

  43.                                   :command=>'328',
    44. 

  44.                                   :params=>['foo','blahblahblah']
    45. 

  45.                                 })}
    46. 

  46.   end # def test_new
    47. 

  47. 

  48. end # class TestPRUNE__MessageHandler
    49. 

  49. 

  50. class TestPRUNE__Message < Test::Unit::TestCase
    51. 

  51. 

  52.   def setup
    53. 

  53.     
    54. 

  54.   end # def setup
    55. 

  55. 

  56.   def teardown
    57. 

  57.     
    58. 

  58.   end # def teardown
    59. 

  59. 

  60.   def test_normalize
    61. 

  61.     assert_equal("FOO", PRUNE::Message.normalize("foo"))
    62. 

  62.     assert_equal("FOO", PRUNE::Message.normalize(:foo))
    63. 

  63.     assert_equal("RPL_WELCOME", PRUNE::Message.normalize("001"))
    64. 

  64.     assert_equal("RPL_YOURHOST", PRUNE::Message.normalize("002"))
    65. 

  65.     assert_equal("RPL_CREATED", PRUNE::Message.normalize("003"))
    66. 

  66.     assert_equal("RPL_MYINFO", PRUNE::Message.normalize("004"))
    67. 

  67.     assert_equal("RPL_BOUNCE", PRUNE::Message.normalize("005"))
    68. 

  68.     assert_equal("RPL_TRACELINK", PRUNE::Message.normalize("200"))
    69. 

  69.     assert_equal("RPL_TRACECONNECTING", PRUNE::Message.normalize("201"))
    70. 

  70.     assert_equal("RPL_TRACEHANDSHAKE", PRUNE::Message.normalize("202"))
    71. 

  71.     assert_equal("RPL_TRACEUNKNOWN", PRUNE::Message.normalize("203"))
    72. 

  72.     assert_equal("RPL_TRACEOPERATOR", PRUNE::Message.normalize("204"))
    73. 

  73.     assert_equal("RPL_TRACEUSER", PRUNE::Message.normalize("205"))
    74. 

  74.     assert_equal("RPL_TRACESERVER", PRUNE::Message.normalize("206"))
    75. 

  75.     assert_equal("RPL_TRACESERVICE", PRUNE::Message.normalize("207"))
    76. 

  76.     assert_equal("RPL_TRACENEWTYPE", PRUNE::Message.normalize("208"))
    77. 

  77.     assert_equal("RPL_TRACECLASS", PRUNE::Message.normalize("209"))
    78. 

  78.     assert_equal("RPL_TRACERECONNECT", PRUNE::Message.normalize("210"))
    79. 

  79.     assert_equal("RPL_STATSLINKINFO", PRUNE::Message.normalize("211"))
    80. 

  80.     assert_equal("RPL_STATSCOMMANDS", PRUNE::Message.normalize("212"))
    81. 

  81.     assert_equal("RPL_STATSCLINE", PRUNE::Message.normalize("213"))
    82. 

  82.     assert_equal("RPL_STATSNLINE", PRUNE::Message.normalize("214"))
    83. 

  83.     assert_equal("RPL_STATSILINE", PRUNE::Message.normalize("215"))
    84. 

  84.     assert_equal("RPL_STATSKLINE", PRUNE::Message.normalize("216"))
    85. 

  85.     assert_equal("RPL_STATSQLINE", PRUNE::Message.normalize("217"))
    86. 

  86.     assert_equal("RPL_STATSYLINE", PRUNE::Message.normalize("218"))
    87. 

  87.     assert_equal("RPL_ENDOFSTATS", PRUNE::Message.normalize("219"))
    88. 

  88.     assert_equal("RPL_STATSPLINE", PRUNE::Message.normalize("220"))
    89. 

  89.     assert_equal("RPL_UMODEIS", PRUNE::Message.normalize("221"))
    90. 

  90.     assert_equal("RPL_STATSDLINE", PRUNE::Message.normalize("225"))
    91. 

  91.     assert_equal("RPL_OPTION", PRUNE::Message.normalize("227"))
    92. 

  92.     assert_equal("RPL_ENDOPTIONS", PRUNE::Message.normalize("228"))
    93. 

  93.     assert_equal("RPL_SERVICEINFO", PRUNE::Message.normalize("231"))
    94. 

  94.     assert_equal("RPL_ENDOFSERVICES", PRUNE::Message.normalize("232"))
    95. 

  95.     assert_equal("RPL_SERVICE", PRUNE::Message.normalize("233"))
    96. 

  96.     assert_equal("RPL_SERVLIST", PRUNE::Message.normalize("234"))
    97. 

  97.     assert_equal("RPL_SERVLISTEND", PRUNE::Message.normalize("235"))
    98. 

  98.     assert_equal("RPL_STATSVLINE", PRUNE::Message.normalize("240"))
    99. 

  99.     assert_equal("RPL_STATSLLINE", PRUNE::Message.normalize("241"))
    100. 

  100.     assert_equal("RPL_STATSUPTIME", PRUNE::Message.normalize("242"))
    101. 

  101.     assert_equal("RPL_STATSOLINE", PRUNE::Message.normalize("243"))
    102. 

  102.     assert_equal("RPL_STATSHLINE", PRUNE::Message.normalize("244"))
    103. 

  103.     assert_equal("245", PRUNE::Message.normalize("245"))
    104. 

  104.     assert_equal("RPL_STATSPING", PRUNE::Message.normalize("246"))
    105. 

  105.     assert_equal("RPL_STATSXLINE", PRUNE::Message.normalize("247"))
    106. 

  106.     assert_equal("RPL_STATSULINE", PRUNE::Message.normalize("248"))
    107. 

  107.     assert_equal("249", PRUNE::Message.normalize("249"))
    108. 

  108.     assert_equal("RPL_STATSCONN", PRUNE::Message.normalize("250"))
    109. 

  109.     assert_equal("RPL_LUSERCLIENT", PRUNE::Message.normalize("251"))
    110. 

  110.     assert_equal("RPL_LUSEROP", PRUNE::Message.normalize("252"))
    111. 

  111.     assert_equal("RPL_LUSERUNKNOWN", PRUNE::Message.normalize("253"))
    112. 

  112.     assert_equal("RPL_LUSERCHANNELS", PRUNE::Message.normalize("254"))
    113. 

  113.     assert_equal("RPL_LUSERME", PRUNE::Message.normalize("255"))
    114. 

  114.     assert_equal("RPL_ADMINME", PRUNE::Message.normalize("256"))
    115. 

  115.     assert_equal("RPL_ADMINLOC1", PRUNE::Message.normalize("257"))
    116. 

  116.     assert_equal("RPL_ADMINLOC2", PRUNE::Message.normalize("258"))
    117. 

  117.     assert_equal("RPL_ADMINEMAIL", PRUNE::Message.normalize("259"))
    118. 

  118.     assert_equal("260", PRUNE::Message.normalize("260"))
    119. 

  119.     assert_equal("RPL_TRACELOG", PRUNE::Message.normalize("261"))
    120. 

  120.     assert_equal("RPL_TRACEEND", PRUNE::Message.normalize("262"))
    121. 

  121.     assert_equal("RPL_TRYAGAIN", PRUNE::Message.normalize("263"))
    122. 

  122.     assert_equal("264", PRUNE::Message.normalize("264"))
    123. 

  123.     assert_equal("RPL_LOCALUSERS", PRUNE::Message.normalize("265"))
    124. 

  124.     assert_equal("RPL_GLOBALUSERS", PRUNE::Message.normalize("266"))
    125. 

  125.     assert_equal("RPL_MODE", PRUNE::Message.normalize("268"))
    126. 

  126.     assert_equal("RPL_ENDMODE", PRUNE::Message.normalize("269"))
    127. 

  127.     assert_equal("RPL_SILELIST", PRUNE::Message.normalize("271"))
    128. 

  128.     assert_equal("RPL_ENDOFSILELIST", PRUNE::Message.normalize("272"))
    129. 

  129.     assert_equal("RPL_CLIENTCAPAB", PRUNE::Message.normalize("290"))
    130. 

  130.     assert_equal("RPL_NONE", PRUNE::Message.normalize("300"))
    131. 

  131.     assert_equal("RPL_AWAY", PRUNE::Message.normalize("301"))
    132. 

  132.     assert_equal("RPL_USERHOST", PRUNE::Message.normalize("302"))
    133. 

  133.     assert_equal("RPL_ISON", PRUNE::Message.normalize("303"))
    134. 

  134.     assert_equal("RPL_TEXT", PRUNE::Message.normalize("304"))
    135. 

  135.     assert_equal("RPL_UNAWAY", PRUNE::Message.normalize("305"))
    136. 

  136.     assert_equal("RPL_NOWAWAY", PRUNE::Message.normalize("306"))
    137. 

  137.     assert_equal("RPL_WHOISUSER", PRUNE::Message.normalize("311"))
    138. 

  138.     assert_equal("RPL_WHOISSERVER", PRUNE::Message.normalize("312"))
    139. 

  139.     assert_equal("RPL_WHOISOPERATOR", PRUNE::Message.normalize("313"))
    140. 

  140.     assert_equal("RPL_WHOWASUSER", PRUNE::Message.normalize("314"))
    141. 

  141.     assert_equal("RPL_ENDOFWHO", PRUNE::Message.normalize("315"))
    142. 

  142.     assert_equal("RPL_WHOISCHANOP", PRUNE::Message.normalize("316"))
    143. 

  143.     assert_equal("RPL_WHOISIDLE", PRUNE::Message.normalize("317"))
    144. 

  144.     assert_equal("RPL_ENDOFWHOIS", PRUNE::Message.normalize("318"))
    145. 

  145.     assert_equal("RPL_WHOISCHANNELS", PRUNE::Message.normalize("319"))
    146. 

  146.     assert_equal("RPL_WHOISIDENTIFIED", PRUNE::Message.normalize("320"))
    147. 

  147.     assert_equal("RPL_LISTSTART", PRUNE::Message.normalize("321"))
    148. 

  148.     assert_equal("RPL_LIST", PRUNE::Message.normalize("322"))
    149. 

  149.     assert_equal("RPL_LISTEND", PRUNE::Message.normalize("323"))
    150. 

  150.     assert_equal("RPL_CHANNELMODEIS", PRUNE::Message.normalize("324"))
    151. 

  151.     assert_equal("RPL_UNIQOPIS", PRUNE::Message.normalize("325"))
    152. 

  152.     assert_equal("RPL_WHOISOPER_PRIVS", PRUNE::Message.normalize("326"))
    153. 

  153.     assert_equal("RPL_WHOISREALHOST", PRUNE::Message.normalize("327"))
    154. 

  154.     assert_equal("RPL_328", PRUNE::Message.normalize("328")) # FIXME
    155. 

  155.     assert_equal("RPL_CHANNELTIMESTAMP", PRUNE::Message.normalize("329"))
    156. 

  156.     assert_equal("RPL_WHOISLOGGEDIN", PRUNE::Message.normalize("330"))
    157. 

  157.     assert_equal("RPL_NOTOPIC", PRUNE::Message.normalize("331"))
    158. 

  158.     assert_equal("RPL_TOPIC", PRUNE::Message.normalize("332"))
    159. 

  159.     assert_equal("RPL_TOPICTIMESTAMP", PRUNE::Message.normalize("333"))
    160. 

  160.     assert_equal("RPL_INVITING", PRUNE::Message.normalize("341"))
    161. 

  161.     assert_equal("RPL_SUMMONING", PRUNE::Message.normalize("342"))
    162. 

  162.     assert_equal("RPL_INVITELIST", PRUNE::Message.normalize("346"))
    163. 

  163.     assert_equal("RPL_ENDOFINVITELIST", PRUNE::Message.normalize("347"))
    164. 

  164.     assert_equal("RPL_EXCEPTLIST", PRUNE::Message.normalize("348"))
    165. 

  165.     assert_equal("RPL_ENDOFEXCEPTLIST", PRUNE::Message.normalize("349"))
    166. 

  166.     assert_equal("350", PRUNE::Message.normalize("350"))
    167. 

  167.     assert_equal("RPL_VERSION", PRUNE::Message.normalize("351"))
    168. 

  168.     assert_equal("RPL_WHOREPLY", PRUNE::Message.normalize("352"))
    169. 

  169.     assert_equal("RPL_NAMREPLY", PRUNE::Message.normalize("353"))
    170. 

  170.     assert_equal("RPL_KILLDONE", PRUNE::Message.normalize("361"))
    171. 

  171.     assert_equal("RPL_CLOSING", PRUNE::Message.normalize("362"))
    172. 

  172.     assert_equal("RPL_CLOSEEND", PRUNE::Message.normalize("363"))
    173. 

  173.     assert_equal("RPL_LINKS", PRUNE::Message.normalize("364"))
    174. 

  174.     assert_equal("RPL_ENDOFLINKS", PRUNE::Message.normalize("365"))
    175. 

  175.     assert_equal("RPL_ENDOFNAMES", PRUNE::Message.normalize("366"))
    176. 

  176.     assert_equal("RPL_BANLIST", PRUNE::Message.normalize("367"))
    177. 

  177.     assert_equal("RPL_ENDOFBANLIST", PRUNE::Message.normalize("368"))
    178. 

  178.     assert_equal("RPL_ENDOFWHOWAS", PRUNE::Message.normalize("369"))
    179. 

  179.     assert_equal("370", PRUNE::Message.normalize("370"))
    180. 

  180.     assert_equal("RPL_INFO", PRUNE::Message.normalize("371"))
    181. 

  181.     assert_equal("RPL_MOTD", PRUNE::Message.normalize("372"))
    182. 

  182.     assert_equal("RPL_INFOSTART", PRUNE::Message.normalize("373"))
    183. 

  183.     assert_equal("RPL_ENDOFINFO", PRUNE::Message.normalize("374"))
    184. 

  184.     assert_equal("RPL_MOTDSTART", PRUNE::Message.normalize("375"))
    185. 

  185.     assert_equal("RPL_ENDOFMOTD", PRUNE::Message.normalize("376"))
    186. 

  186.     assert_equal("RPL_MAP", PRUNE::Message.normalize("377"))
    187. 

  187.     assert_equal("RPL_ENDOFMAP", PRUNE::Message.normalize("378"))
    188. 

  188.     assert_equal("RPL_FORWARD", PRUNE::Message.normalize("379"))
    189. 

  189.     assert_equal("RPL_YOUREOPER", PRUNE::Message.normalize("381"))
    190. 

  190.     assert_equal("RPL_REHASHING", PRUNE::Message.normalize("382"))
    191. 

  191.     assert_equal("RPL_YOURESERVICE", PRUNE::Message.normalize("383"))
    192. 

  192.     assert_equal("RPL_MYPORTIS", PRUNE::Message.normalize("384"))
    193. 

  193.     assert_equal("RPL_NOTOPERANYMORE", PRUNE::Message.normalize("385"))
    194. 

  194.     assert_equal("RPL_TIME", PRUNE::Message.normalize("391"))
    195. 

  195.     assert_equal("RPL_USERSSTART", PRUNE::Message.normalize("392"))
    196. 

  196.     assert_equal("RPL_USERS", PRUNE::Message.normalize("393"))
    197. 

  197.     assert_equal("RPL_ENDOFUSERS", PRUNE::Message.normalize("394"))
    198. 

  198.     assert_equal("RPL_NOUSERS", PRUNE::Message.normalize("395"))
    199. 

  199.     assert_equal("RPL_MESSAGE", PRUNE::Message.normalize("399"))
    200. 

  200.     assert_equal("RPL_CMDACT", PRUNE::Message.normalize("-1"))
    201. 

  201.     assert_equal("ERR_NOSUCHNICK", PRUNE::Message.normalize("401"))
    202. 

  202.     assert_equal("ERR_NOSUCHSERVER", PRUNE::Message.normalize("402"))
    203. 

  203.     assert_equal("ERR_NOSUCHCHANNEL", PRUNE::Message.normalize("403"))
    204. 

  204.     assert_equal("ERR_CANNOTSENDTOCHAN", PRUNE::Message.normalize("404"))
    205. 

  205.     assert_equal("ERR_TOOMANYCHANNELS", PRUNE::Message.normalize("405"))
    206. 

  206.     assert_equal("ERR_WASNOSUCHNICK", PRUNE::Message.normalize("406"))
    207. 

  207.     assert_equal("ERR_TOOMANYTARGETS", PRUNE::Message.normalize("407"))
    208. 

  208.     assert_equal("ERR_NOSUCHSERVICE", PRUNE::Message.normalize("408"))
    209. 

  209.     assert_equal("ERR_NOORIGIN", PRUNE::Message.normalize("409"))
    210. 

  210.     assert_equal("ERR_SERVICES_OFFLINE", PRUNE::Message.normalize("410"))
    211. 

  211.     assert_equal("ERR_NORECIPIENT", PRUNE::Message.normalize("411"))
    212. 

  212.     assert_equal("ERR_NOTEXTTOSEND", PRUNE::Message.normalize("412"))
    213. 

  213.     assert_equal("ERR_NOTOPLEVEL", PRUNE::Message.normalize("413"))
    214. 

  214.     assert_equal("ERR_WILDTOPLEVEL", PRUNE::Message.normalize("414"))
    215. 

  215.     assert_equal("ERR_BADMASK", PRUNE::Message.normalize("415"))
    216. 

  216.     assert_equal("ERR_UNKNOWNCOMMAND", PRUNE::Message.normalize("421"))
    217. 

  217.     assert_equal("ERR_NOMOTD", PRUNE::Message.normalize("422"))
    218. 

  218.     assert_equal("ERR_NOADMININFO", PRUNE::Message.normalize("423"))
    219. 

  219.     assert_equal("ERR_FILEERROR", PRUNE::Message.normalize("424"))
    220. 

  220.     assert_equal("ERR_NONICKNAMEGIVEN", PRUNE::Message.normalize("431"))
    221. 

  221.     assert_equal("ERR_ERRONEUSNICKNAME", PRUNE::Message.normalize("432"))
    222. 

  222.     assert_equal("ERR_NICKNAMEINUSE", PRUNE::Message.normalize("433"))
    223. 

  223.     assert_equal("434", PRUNE::Message.normalize("434"))
    224. 

  224.     assert_equal("435", PRUNE::Message.normalize("435"))
    225. 

  225.     assert_equal("ERR_NICKCOLLISION", PRUNE::Message.normalize("436"))
    226. 

  226.     assert_equal("ERR_UNAVAILRESOURCE", PRUNE::Message.normalize("437"))
    227. 

  227.     assert_equal("ERR_BANNICKCHANGE", PRUNE::Message.normalize("438"))
    228. 

  228.     assert_equal("ERR_USERNOTINCHANNEL", PRUNE::Message.normalize("441"))
    229. 

  229.     assert_equal("ERR_NOTONCHANNEL", PRUNE::Message.normalize("442"))
    230. 

  230.     assert_equal("ERR_USERONCHANNEL", PRUNE::Message.normalize("443"))
    231. 

  231.     assert_equal("ERR_NOLOGIN", PRUNE::Message.normalize("444"))
    232. 

  232.     assert_equal("ERR_SUMMONDISABLED", PRUNE::Message.normalize("445"))
    233. 

  233.     assert_equal("ERR_USERSDISABLED", PRUNE::Message.normalize("446"))
    234. 

  234.     assert_equal("ERR_TARGETNINVITE", PRUNE::Message.normalize("447"))
    235. 

  235.     assert_equal("ERR_SOURCENINVITE", PRUNE::Message.normalize("448"))
    236. 

  236.     assert_equal("ERR_NOTREGISTERED", PRUNE::Message.normalize("451"))
    237. 

  237.     assert_equal("ERR_NEEDMOREPARAMS", PRUNE::Message.normalize("461"))
    238. 

  238.     assert_equal("ERR_ALREADYREGISTRED", PRUNE::Message.normalize("462"))
    239. 

  239.     assert_equal("ERR_NOPERMFORHOST", PRUNE::Message.normalize("463"))
    240. 

  240.     assert_equal("ERR_PASSWDMISMATCH", PRUNE::Message.normalize("464"))
    241. 

  241.     assert_equal("ERR_YOUREBANNEDCREEP", PRUNE::Message.normalize("465"))
    242. 

  242.     assert_equal("ERR_YOUWILLBEBANNED", PRUNE::Message.normalize("466"))
    243. 

  243.     assert_equal("ERR_KEYSE", PRUNE::Message.normalize("467"))
    244. 

  244.     assert_equal("ERR_INVALIDUSERNAME", PRUNE::Message.normalize("468"))
    245. 

  245.     assert_equal("ERR_LINKCHANNEL", PRUNE::Message.normalize("470"))
    246. 

  246.     assert_equal("ERR_CHANNELISFULL", PRUNE::Message.normalize("471"))
    247. 

  247.     assert_equal("ERR_UNKNOWNMODE", PRUNE::Message.normalize("472"))
    248. 

  248.     assert_equal("ERR_INVITEONLYCHAN", PRUNE::Message.normalize("473"))
    249. 

  249.     assert_equal("ERR_BANNEDFROMCHAN", PRUNE::Message.normalize("474"))
    250. 

  250.     assert_equal("ERR_BADCHANNELKEY", PRUNE::Message.normalize("475"))
    251. 

  251.     assert_equal("ERR_BADCHANMASK", PRUNE::Message.normalize("476"))
    252. 

  252.     assert_equal("ERR_NOCHANMODES", PRUNE::Message.normalize("477"))
    253. 

  253.     assert_equal("ERR_BANLISTFULL", PRUNE::Message.normalize("478"))
    254. 

  254.     assert_equal("ERR_BADCHANNAME", PRUNE::Message.normalize("479"))
    255. 

  255.     assert_equal("ERR_THROTTLED", PRUNE::Message.normalize("480"))
    256. 

  256.     assert_equal("ERR_NOPRIVILEGES", PRUNE::Message.normalize("481"))
    257. 

  257.     assert_equal("ERR_CHANOPRIVSNEEDED", PRUNE::Message.normalize("482"))
    258. 

  258.     assert_equal("ERR_CANTKILLSERVER", PRUNE::Message.normalize("483"))
    259. 

  259.     assert_equal("ERR_RESTRICTED", PRUNE::Message.normalize("484"))
    260. 

  260.     assert_equal("ERR_UNIQOPPRIVSNEEDED", PRUNE::Message.normalize("485"))
    261. 

  261.     assert_equal("ERR_RESTRICTED", PRUNE::Message.normalize("486"))
    262. 

  262.     assert_equal("ERR_NO_OP_SPLIT", PRUNE::Message.normalize("487"))
    263. 

  263.     assert_equal("ERR_NEED_UMODE", PRUNE::Message.normalize("488"))
    264. 

  264.     assert_equal("ERR_NOOPERHOST", PRUNE::Message.normalize("491"))
    265. 

  265.     assert_equal("ERR_NOSERVICEHOST", PRUNE::Message.normalize("492"))
    266. 

  266.     assert_equal("ERR_UMODEUNKNOWNFLAG", PRUNE::Message.normalize("501"))
    267. 

  267.     assert_equal("ERR_USERSDONTMATCH", PRUNE::Message.normalize("502"))
    268. 

  268.     assert_equal("ERR_GHOSTEDCLIENT", PRUNE::Message.normalize("503"))
    269. 

  269.     assert_equal("ERR_BLOCKING_NOTID", PRUNE::Message.normalize("505"))
    270. 

  270.     assert_equal("ERR_QUIETUNIDENT", PRUNE::Message.normalize("506"))
    271. 

  271.     assert_equal("ERR_SILELISTFULL", PRUNE::Message.normalize("511"))
    272. 

  272.     assert_equal("ERR_MAXMAPNODES", PRUNE::Message.normalize("512"))
    273. 

  273.     assert_equal("ERR_MAXFORWARDING", PRUNE::Message.normalize("513"))
    274. 

  274.     assert_equal("ERR_NOFORWARDING", PRUNE::Message.normalize("514"))
    275. 

  275.     assert_equal("ERR_NOUNIDENTIFIED", PRUNE::Message.normalize("515"))
    276. 

  276.     assert_equal("RPL_LOGGEDIN", PRUNE::Message.normalize("901"))
    277. 

  277.     assert_equal("RPL_LOGGEDOUT", PRUNE::Message.normalize("902"))
    278. 

  278.     assert_equal(1, PRUNE::Message.normalize(1))
    279. 

  279.   end # def test_normalize
    280. 

  280. 

  281.   def test_sanitize
    282. 

  282.     assert_equal(:FOO, PRUNE::Message.sanitize("foo"))
    283. 

  283.     assert_equal(:FOO, PRUNE::Message.sanitize(:foo))
    284. 

  284.     assert_equal(:RPL_WELCOME, PRUNE::Message.sanitize("001"))
    285. 

  285.     assert_equal(:RPL_YOURHOST, PRUNE::Message.sanitize("002"))
    286. 

  286.     assert_equal(:RPL_CREATED, PRUNE::Message.sanitize("003"))
    287. 

  287.     assert_equal(:RPL_MYINFO, PRUNE::Message.sanitize("004"))
    288. 

  288.     assert_equal(:RPL_BOUNCE, PRUNE::Message.sanitize("005"))
    289. 

  289.     assert_equal(:RPL_TRACELINK, PRUNE::Message.sanitize("200"))
    290. 

  290.     assert_equal(:RPL_TRACECONNECTING, PRUNE::Message.sanitize("201"))
    291. 

  291.     assert_equal(:RPL_TRACEHANDSHAKE, PRUNE::Message.sanitize("202"))
    292. 

  292.     assert_equal(:RPL_TRACEUNKNOWN, PRUNE::Message.sanitize("203"))
    293. 

  293.     assert_equal(:RPL_TRACEOPERATOR, PRUNE::Message.sanitize("204"))
    294. 

  294.     assert_equal(:RPL_TRACEUSER, PRUNE::Message.sanitize("205"))
    295. 

  295.     assert_equal(:RPL_TRACESERVER, PRUNE::Message.sanitize("206"))
    296. 

  296.     assert_equal(:RPL_TRACESERVICE, PRUNE::Message.sanitize("207"))
    297. 

  297.     assert_equal(:RPL_TRACENEWTYPE, PRUNE::Message.sanitize("208"))
    298. 

  298.     assert_equal(:RPL_TRACECLASS, PRUNE::Message.sanitize("209"))
    299. 

  299.     assert_equal(:RPL_TRACERECONNECT, PRUNE::Message.sanitize("210"))
    300. 

  300.     assert_equal(:RPL_STATSLINKINFO, PRUNE::Message.sanitize("211"))
    301. 

  301.     assert_equal(:RPL_STATSCOMMANDS, PRUNE::Message.sanitize("212"))
    302. 

  302.     assert_equal(:RPL_STATSCLINE, PRUNE::Message.sanitize("213"))
    303. 

  303.     assert_equal(:RPL_STATSNLINE, PRUNE::Message.sanitize("214"))
    304. 

  304.     assert_equal(:RPL_STATSILINE, PRUNE::Message.sanitize("215"))
    305. 

  305.     assert_equal(:RPL_STATSKLINE, PRUNE::Message.sanitize("216"))
    306. 

  306.     assert_equal(:RPL_STATSQLINE, PRUNE::Message.sanitize("217"))
    307. 

  307.     assert_equal(:RPL_STATSYLINE, PRUNE::Message.sanitize("218"))
    308. 

  308.     assert_equal(:RPL_ENDOFSTATS, PRUNE::Message.sanitize("219"))
    309. 

  309.     assert_equal(:RPL_STATSPLINE, PRUNE::Message.sanitize("220"))
    310. 

  310.     assert_equal(:RPL_UMODEIS, PRUNE::Message.sanitize("221"))
    311. 

  311.     assert_equal(:RPL_STATSDLINE, PRUNE::Message.sanitize("225"))
    312. 

  312.     assert_equal(:RPL_OPTION, PRUNE::Message.sanitize("227"))
    313. 

  313.     assert_equal(:RPL_ENDOPTIONS, PRUNE::Message.sanitize("228"))
    314. 

  314.     assert_equal(:RPL_SERVICEINFO, PRUNE::Message.sanitize("231"))
    315. 

  315.     assert_equal(:RPL_ENDOFSERVICES, PRUNE::Message.sanitize("232"))
    316. 

  316.     assert_equal(:RPL_SERVICE, PRUNE::Message.sanitize("233"))
    317. 

  317.     assert_equal(:RPL_SERVLIST, PRUNE::Message.sanitize("234"))
    318. 

  318.     assert_equal(:RPL_SERVLISTEND, PRUNE::Message.sanitize("235"))
    319. 

  319.     assert_equal(:RPL_STATSVLINE, PRUNE::Message.sanitize("240"))
    320. 

  320.     assert_equal(:RPL_STATSLLINE, PRUNE::Message.sanitize("241"))
    321. 

  321.     assert_equal(:RPL_STATSUPTIME, PRUNE::Message.sanitize("242"))
    322. 

  322.     assert_equal(:RPL_STATSOLINE, PRUNE::Message.sanitize("243"))
    323. 

  323.     assert_equal(:RPL_STATSHLINE, PRUNE::Message.sanitize("244"))
    324. 

  324.     assert_equal(:"245", PRUNE::Message.sanitize("245"))
    325. 

  325.     assert_equal(:RPL_STATSPING, PRUNE::Message.sanitize("246"))
    326. 

  326.     assert_equal(:RPL_STATSXLINE, PRUNE::Message.sanitize("247"))
    327. 

  327.     assert_equal(:RPL_STATSULINE, PRUNE::Message.sanitize("248"))
    328. 

  328.     assert_equal(:"249", PRUNE::Message.sanitize("249"))
    329. 

  329.     assert_equal(:RPL_STATSCONN, PRUNE::Message.sanitize("250"))
    330. 

  330.     assert_equal(:RPL_LUSERCLIENT, PRUNE::Message.sanitize("251"))
    331. 

  331.     assert_equal(:RPL_LUSEROP, PRUNE::Message.sanitize("252"))
    332. 

  332.     assert_equal(:RPL_LUSERUNKNOWN, PRUNE::Message.sanitize("253"))
    333. 

  333.     assert_equal(:RPL_LUSERCHANNELS, PRUNE::Message.sanitize("254"))
    334. 

  334.     assert_equal(:RPL_LUSERME, PRUNE::Message.sanitize("255"))
    335. 

  335.     assert_equal(:RPL_ADMINME, PRUNE::Message.sanitize("256"))
    336. 

  336.     assert_equal(:RPL_ADMINLOC1, PRUNE::Message.sanitize("257"))
    337. 

  337.     assert_equal(:RPL_ADMINLOC2, PRUNE::Message.sanitize("258"))
    338. 

  338.     assert_equal(:RPL_ADMINEMAIL, PRUNE::Message.sanitize("259"))
    339. 

  339.     assert_equal(:"260", PRUNE::Message.sanitize("260"))
    340. 

  340.     assert_equal(:RPL_TRACELOG, PRUNE::Message.sanitize("261"))
    341. 

  341.     assert_equal(:RPL_TRACEEND, PRUNE::Message.sanitize("262"))
    342. 

  342.     assert_equal(:RPL_TRYAGAIN, PRUNE::Message.sanitize("263"))
    343. 

  343.     assert_equal(:"264", PRUNE::Message.sanitize("264"))
    344. 

  344.     assert_equal(:RPL_LOCALUSERS, PRUNE::Message.sanitize("265"))
    345. 

  345.     assert_equal(:RPL_GLOBALUSERS, PRUNE::Message.sanitize("266"))
    346. 

  346.     assert_equal(:RPL_NONE, PRUNE::Message.sanitize("300"))
    347. 

  347.     assert_equal(:RPL_AWAY, PRUNE::Message.sanitize("301"))
    348. 

  348.     assert_equal(:RPL_USERHOST, PRUNE::Message.sanitize("302"))
    349. 

  349.     assert_equal(:RPL_ISON, PRUNE::Message.sanitize("303"))
    350. 

  350.     assert_equal(:RPL_TEXT, PRUNE::Message.sanitize("304"))
    351. 

  351.     assert_equal(:RPL_UNAWAY, PRUNE::Message.sanitize("305"))
    352. 

  352.     assert_equal(:RPL_NOWAWAY, PRUNE::Message.sanitize("306"))
    353. 

  353.     assert_equal(:RPL_WHOISUSER, PRUNE::Message.sanitize("311"))
    354. 

  354.     assert_equal(:RPL_WHOISSERVER, PRUNE::Message.sanitize("312"))
    355. 

  355.     assert_equal(:RPL_WHOISOPERATOR, PRUNE::Message.sanitize("313"))
    356. 

  356.     assert_equal(:RPL_WHOWASUSER, PRUNE::Message.sanitize("314"))
    357. 

  357.     assert_equal(:RPL_ENDOFWHO, PRUNE::Message.sanitize("315"))
    358. 

  358.     assert_equal(:RPL_WHOISCHANOP, PRUNE::Message.sanitize("316"))
    359. 

  359.     assert_equal(:RPL_WHOISIDLE, PRUNE::Message.sanitize("317"))
    360. 

  360.     assert_equal(:RPL_ENDOFWHOIS, PRUNE::Message.sanitize("318"))
    361. 

  361.     assert_equal(:RPL_WHOISCHANNELS, PRUNE::Message.sanitize("319"))
    362. 

  362.     assert_equal(:RPL_WHOISIDENTIFIED, PRUNE::Message.sanitize("320"))
    363. 

  363.     assert_equal(:RPL_LISTSTART, PRUNE::Message.sanitize("321"))
    364. 

  364.     assert_equal(:RPL_LIST, PRUNE::Message.sanitize("322"))
    365. 

  365.     assert_equal(:RPL_LISTEND, PRUNE::Message.sanitize("323"))
    366. 

  366.     assert_equal(:RPL_CHANNELMODEIS, PRUNE::Message.sanitize("324"))
    367. 

  367.     assert_equal(:RPL_UNIQOPIS, PRUNE::Message.sanitize("325"))
    368. 

  368.     assert_equal(:RPL_CHANNELTIMESTAMP, PRUNE::Message.sanitize("329"))
    369. 

  369.     assert_equal(:RPL_WHOISLOGGEDIN, PRUNE::Message.sanitize("330"))
    370. 

  370.     assert_equal(:RPL_NOTOPIC, PRUNE::Message.sanitize("331"))
    371. 

  371.     assert_equal(:RPL_TOPIC, PRUNE::Message.sanitize("332"))
    372. 

  372.     assert_equal(:RPL_TOPICTIMESTAMP, PRUNE::Message.sanitize("333"))
    373. 

  373.     assert_equal(:RPL_INVITING, PRUNE::Message.sanitize("341"))
    374. 

  374.     assert_equal(:RPL_SUMMONING, PRUNE::Message.sanitize("342"))
    375. 

  375.     assert_equal(:RPL_INVITELIST, PRUNE::Message.sanitize("346"))
    376. 

  376.     assert_equal(:RPL_ENDOFINVITELIST, PRUNE::Message.sanitize("347"))
    377. 

  377.     assert_equal(:RPL_EXCEPTLIST, PRUNE::Message.sanitize("348"))
    378. 

  378.     assert_equal(:RPL_ENDOFEXCEPTLIST, PRUNE::Message.sanitize("349"))
    379. 

  379.     assert_equal(:"350", PRUNE::Message.sanitize("350"))
    380. 

  380.     assert_equal(:RPL_VERSION, PRUNE::Message.sanitize("351"))
    381. 

  381.     assert_equal(:RPL_WHOREPLY, PRUNE::Message.sanitize("352"))
    382. 

  382.     assert_equal(:RPL_NAMREPLY, PRUNE::Message.sanitize("353"))
    383. 

  383.     assert_equal(:RPL_KILLDONE, PRUNE::Message.sanitize("361"))
    384. 

  384.     assert_equal(:RPL_CLOSING, PRUNE::Message.sanitize("362"))
    385. 

  385.     assert_equal(:RPL_CLOSEEND, PRUNE::Message.sanitize("363"))
    386. 

  386.     assert_equal(:RPL_LINKS, PRUNE::Message.sanitize("364"))
    387. 

  387.     assert_equal(:RPL_ENDOFLINKS, PRUNE::Message.sanitize("365"))
    388. 

  388.     assert_equal(:RPL_ENDOFNAMES, PRUNE::Message.sanitize("366"))
    389. 

  389.     assert_equal(:RPL_BANLIST, PRUNE::Message.sanitize("367"))
    390. 

  390.     assert_equal(:RPL_ENDOFBANLIST, PRUNE::Message.sanitize("368"))
    391. 

  391.     assert_equal(:RPL_ENDOFWHOWAS, PRUNE::Message.sanitize("369"))
    392. 

  392.     assert_equal(:"370", PRUNE::Message.sanitize("370"))
    393. 

  393.     assert_equal(:RPL_INFO, PRUNE::Message.sanitize("371"))
    394. 

  394.     assert_equal(:RPL_MOTD, PRUNE::Message.sanitize("372"))
    395. 

  395.     assert_equal(:RPL_INFOSTART, PRUNE::Message.sanitize("373"))
    396. 

  396.     assert_equal(:RPL_ENDOFINFO, PRUNE::Message.sanitize("374"))
    397. 

  397.     assert_equal(:RPL_MOTDSTART, PRUNE::Message.sanitize("375"))
    398. 

  398.     assert_equal(:RPL_ENDOFMOTD, PRUNE::Message.sanitize("376"))
    399. 

  399.     assert_equal(:RPL_YOUREOPER, PRUNE::Message.sanitize("381"))
    400. 

  400.     assert_equal(:RPL_REHASHING, PRUNE::Message.sanitize("382"))
    401. 

  401.     assert_equal(:RPL_YOURESERVICE, PRUNE::Message.sanitize("383"))
    402. 

  402.     assert_equal(:RPL_MYPORTIS, PRUNE::Message.sanitize("384"))
    403. 

  403.     assert_equal(:RPL_TIME, PRUNE::Message.sanitize("391"))
    404. 

  404.     assert_equal(:RPL_USERSSTART, PRUNE::Message.sanitize("392"))
    405. 

  405.     assert_equal(:RPL_USERS, PRUNE::Message.sanitize("393"))
    406. 

  406.     assert_equal(:RPL_ENDOFUSERS, PRUNE::Message.sanitize("394"))
    407. 

  407.     assert_equal(:RPL_NOUSERS, PRUNE::Message.sanitize("395"))
    408. 

  408.     assert_equal(:RPL_CMDACT, PRUNE::Message.sanitize("-1"))
    409. 

  409.     assert_equal(:ERR_NOSUCHNICK, PRUNE::Message.sanitize("401"))
    410. 

  410.     assert_equal(:ERR_NOSUCHSERVER, PRUNE::Message.sanitize("402"))
    411. 

  411.     assert_equal(:ERR_NOSUCHCHANNEL, PRUNE::Message.sanitize("403"))
    412. 

  412.     assert_equal(:ERR_CANNOTSENDTOCHAN, PRUNE::Message.sanitize("404"))
    413. 

  413.     assert_equal(:ERR_TOOMANYCHANNELS, PRUNE::Message.sanitize("405"))
    414. 

  414.     assert_equal(:ERR_WASNOSUCHNICK, PRUNE::Message.sanitize("406"))
    415. 

  415.     assert_equal(:ERR_TOOMANYTARGETS, PRUNE::Message.sanitize("407"))
    416. 

  416.     assert_equal(:ERR_NOSUCHSERVICE, PRUNE::Message.sanitize("408"))
    417. 

  417.     assert_equal(:ERR_NOORIGIN, PRUNE::Message.sanitize("409"))
    418. 

  418.     assert_equal(:ERR_SERVICES_OFFLINE, PRUNE::Message.sanitize("410"))
    419. 

  419.     assert_equal(:ERR_NORECIPIENT, PRUNE::Message.sanitize("411"))
    420. 

  420.     assert_equal(:ERR_NOTEXTTOSEND, PRUNE::Message.sanitize("412"))
    421. 

  421.     assert_equal(:ERR_NOTOPLEVEL, PRUNE::Message.sanitize("413"))
    422. 

  422.     assert_equal(:ERR_WILDTOPLEVEL, PRUNE::Message.sanitize("414"))
    423. 

  423.     assert_equal(:ERR_BADMASK, PRUNE::Message.sanitize("415"))
    424. 

  424.     assert_equal(:ERR_UNKNOWNCOMMAND, PRUNE::Message.sanitize("421"))
    425. 

  425.     assert_equal(:ERR_NOMOTD, PRUNE::Message.sanitize("422"))
    426. 

  426.     assert_equal(:ERR_NOADMININFO, PRUNE::Message.sanitize("423"))
    427. 

  427.     assert_equal(:ERR_FILEERROR, PRUNE::Message.sanitize("424"))
    428. 

  428.     assert_equal(:ERR_NONICKNAMEGIVEN, PRUNE::Message.sanitize("431"))
    429. 

  429.     assert_equal(:ERR_ERRONEUSNICKNAME, PRUNE::Message.sanitize("432"))
    430. 

  430.     assert_equal(:ERR_NICKNAMEINUSE, PRUNE::Message.sanitize("433"))
    431. 

  431.     assert_equal(:"434", PRUNE::Message.sanitize("434"))
    432. 

  432.     assert_equal(:"435", PRUNE::Message.sanitize("435"))
    433. 

  433.     assert_equal(:ERR_NICKCOLLISION, PRUNE::Message.sanitize("436"))
    434. 

  434.     assert_equal(:ERR_UNAVAILRESOURCE, PRUNE::Message.sanitize("437"))
    435. 

  435.     assert_equal(:ERR_USERNOTINCHANNEL, PRUNE::Message.sanitize("441"))
    436. 

  436.     assert_equal(:ERR_NOTONCHANNEL, PRUNE::Message.sanitize("442"))
    437. 

  437.     assert_equal(:ERR_USERONCHANNEL, PRUNE::Message.sanitize("443"))
    438. 

  438.     assert_equal(:ERR_NOLOGIN, PRUNE::Message.sanitize("444"))
    439. 

  439.     assert_equal(:ERR_SUMMONDISABLED, PRUNE::Message.sanitize("445"))
    440. 

  440.     assert_equal(:ERR_USERSDISABLED, PRUNE::Message.sanitize("446"))
    441. 

  441.     assert_equal(:ERR_NOTREGISTERED, PRUNE::Message.sanitize("451"))
    442. 

  442.     assert_equal(:ERR_NEEDMOREPARAMS, PRUNE::Message.sanitize("461"))
    443. 

  443.     assert_equal(:ERR_ALREADYREGISTRED, PRUNE::Message.sanitize("462"))
    444. 

  444.     assert_equal(:ERR_NOPERMFORHOST, PRUNE::Message.sanitize("463"))
    445. 

  445.     assert_equal(:ERR_PASSWDMISMATCH, PRUNE::Message.sanitize("464"))
    446. 

  446.     assert_equal(:ERR_YOUREBANNEDCREEP, PRUNE::Message.sanitize("465"))
    447. 

  447.     assert_equal(:ERR_YOUWILLBEBANNED, PRUNE::Message.sanitize("466"))
    448. 

  448.     assert_equal(:ERR_KEYSE, PRUNE::Message.sanitize("467"))
    449. 

  449.     assert_equal(:ERR_INVALIDUSERNAME, PRUNE::Message.sanitize("468"))
    450. 

  450.     assert_equal(:ERR_CHANNELISFULL, PRUNE::Message.sanitize("471"))
    451. 

  451.     assert_equal(:ERR_UNKNOWNMODE, PRUNE::Message.sanitize("472"))
    452. 

  452.     assert_equal(:ERR_INVITEONLYCHAN, PRUNE::Message.sanitize("473"))
    453. 

  453.     assert_equal(:ERR_BANNEDFROMCHAN, PRUNE::Message.sanitize("474"))
    454. 

  454.     assert_equal(:ERR_BADCHANNELKEY, PRUNE::Message.sanitize("475"))
    455. 

  455.     assert_equal(:ERR_BADCHANMASK, PRUNE::Message.sanitize("476"))
    456. 

  456.     assert_equal(:ERR_NOCHANMODES, PRUNE::Message.sanitize("477"))
    457. 

  457.     assert_equal(:ERR_BANLISTFULL, PRUNE::Message.sanitize("478"))
    458. 

  458.     assert_equal(:ERR_BADCHANNAME, PRUNE::Message.sanitize("479"))
    459. 

  459.     assert_equal(:ERR_THROTTLED, PRUNE::Message.sanitize("480"))
    460. 

  460.     assert_equal(:ERR_NOPRIVILEGES, PRUNE::Message.sanitize("481"))
    461. 

  461.     assert_equal(:ERR_CHANOPRIVSNEEDED, PRUNE::Message.sanitize("482"))
    462. 

  462.     assert_equal(:ERR_CANTKILLSERVER, PRUNE::Message.sanitize("483"))
    463. 

  463.     assert_equal(:ERR_RESTRICTED, PRUNE::Message.sanitize("484"))
    464. 

  464.     assert_equal(:ERR_UNIQOPPRIVSNEEDED, PRUNE::Message.sanitize("485"))
    465. 

  465.     assert_equal(:ERR_NOOPERHOST, PRUNE::Message.sanitize("491"))
    466. 

  466.     assert_equal(:ERR_NOSERVICEHOST, PRUNE::Message.sanitize("492"))
    467. 

  467.     assert_equal(:ERR_UMODEUNKNOWNFLAG, PRUNE::Message.sanitize("501"))
    468. 

  468.     assert_equal(:ERR_USERSDONTMATCH, PRUNE::Message.sanitize("502"))
    469. 

  469.     assert_equal(nil, PRUNE::Message.sanitize(1))
    470. 

  470.   end # def test_sanitize
    471. 

  471. 

  472.   def test_channelinfo
    473. 

  473.     assert_equal(nil, PRUNE::Message.channelinfo("foo"))
    474. 

  474.     assert_equal(nil, PRUNE::Message.channelinfo("connect"))
    475. 

  475.     assert_equal(nil, PRUNE::Message.channelinfo("Connect"))
    476. 

  476.     assert_equal(nil, PRUNE::Message.channelinfo(:connect))
    477. 

  477.     assert_equal(nil, PRUNE::Message.channelinfo(:die))
    478. 

  478.     assert_equal(nil, PRUNE::Message.channelinfo(:error))
    479. 

  479.     assert_equal(nil, PRUNE::Message.channelinfo(:ping))
    480. 

  480.     assert_equal(nil, PRUNE::Message.channelinfo(:pong))
    481. 

  481.     assert_equal(nil, PRUNE::Message.channelinfo(:rehash))
    482. 

  482.     assert_equal(nil, PRUNE::Message.channelinfo(:restart))
    483. 

  483.     assert_equal(nil, PRUNE::Message.channelinfo(:service))
    484. 

  484.     assert_equal(nil, PRUNE::Message.channelinfo(:squit))
    485. 

  485.     assert_equal(nil, PRUNE::Message.channelinfo(:trace))
    486. 

  486.     assert_equal(nil, PRUNE::Message.channelinfo(:wallops))
    487. 

  487.     assert_equal(nil, PRUNE::Message.channelinfo(:admin))
    488. 

  488.     assert_equal(nil, PRUNE::Message.channelinfo(:away))
    489. 

  489.     assert_equal(nil, PRUNE::Message.channelinfo(:info))
    490. 

  490.     assert_equal(nil, PRUNE::Message.channelinfo(:links))
    491. 

  491.     assert_equal(nil, PRUNE::Message.channelinfo(:list))
    492. 

  492.     assert_equal(nil, PRUNE::Message.channelinfo(:lusers))
    493. 

  493.     assert_equal(nil, PRUNE::Message.channelinfo(:motd))
    494. 

  494.     assert_equal(nil, PRUNE::Message.channelinfo(:oper))
    495. 

  495.     assert_equal(nil, PRUNE::Message.channelinfo(:pass))
    496. 

  496.     assert_equal(nil, PRUNE::Message.channelinfo(:quit))
    497. 

  497.     assert_equal(nil, PRUNE::Message.channelinfo(:servlist))
    498. 

  498.     assert_equal(nil, PRUNE::Message.channelinfo(:squery))
    499. 

  499.     assert_equal(nil, PRUNE::Message.channelinfo(:stats))
    500. 

  500.     assert_equal(nil, PRUNE::Message.channelinfo(:time))
    501. 

  501.     assert_equal(nil, PRUNE::Message.channelinfo(:user))
    502. 

  502.     assert_equal(nil, PRUNE::Message.channelinfo(:users))
    503. 

  503.     assert_equal(nil, PRUNE::Message.channelinfo(:version))
    504. 

  504.     assert_not_nil(PRUNE::Message.channelinfo(:invite))
    505. 

  505.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:invite).location)
    506. 

  506.     assert_equal(1, PRUNE::Message.channelinfo(:invite).index)
    507. 

  507.     assert_equal(nil, PRUNE::Message.channelinfo(:ison))
    508. 

  508.     assert_not_nil(PRUNE::Message.channelinfo(:join))
    509. 

  509.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:join).location)
    510. 

  510.     assert_equal(0, PRUNE::Message.channelinfo(:join).index)
    511. 

  511.     assert_not_nil(PRUNE::Message.channelinfo(:kick))
    512. 

  512.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:kick).location)
    513. 

  513.     assert_equal(0, PRUNE::Message.channelinfo(:kick).index)
    514. 

  514.     assert_equal(nil, PRUNE::Message.channelinfo(:kill))
    515. 

  515.     assert_not_nil(PRUNE::Message.channelinfo(:mode))
    516. 

  516.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:mode).location)
    517. 

  517.     assert_equal(0, PRUNE::Message.channelinfo(:mode).index)
    518. 

  518.     assert_not_nil(PRUNE::Message.channelinfo(:names))
    519. 

  519.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:names).location)
    520. 

  520.     assert_equal(0, PRUNE::Message.channelinfo(:names).index)
    521. 

  521.     assert_equal(nil, PRUNE::Message.channelinfo(:nick))
    522. 

  522.     assert_not_nil(PRUNE::Message.channelinfo(:notice))
    523. 

  523.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:notice).location)
    524. 

  524.     assert_equal(0, PRUNE::Message.channelinfo(:notice).index)
    525. 

  525.     assert_not_nil(PRUNE::Message.channelinfo(:part))
    526. 

  526.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:part).location)
    527. 

  527.     assert_equal(0, PRUNE::Message.channelinfo(:part).index)
    528. 

  528.     assert_not_nil(PRUNE::Message.channelinfo(:privmsg))
    529. 

  529.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:privmsg).location)
    530. 

  530.     assert_equal(0, PRUNE::Message.channelinfo(:privmsg).index)
    531. 

  531.     assert_equal(nil, PRUNE::Message.channelinfo(:summon))
    532. 

  532.     assert_not_nil(PRUNE::Message.channelinfo(:topic))
    533. 

  533.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:topic).location)
    534. 

  534.     assert_equal(0, PRUNE::Message.channelinfo(:topic).index)
    535. 

  535.     assert_equal(nil, PRUNE::Message.channelinfo(:userhost))
    536. 

  536.     assert_not_nil(PRUNE::Message.channelinfo(:who))
    537. 

  537.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo(:who).location)
    538. 

  538.     assert_equal(0, PRUNE::Message.channelinfo(:who).index)
    539. 

  539.     assert_equal(nil, PRUNE::Message.channelinfo(:whois))
    540. 

  540.     assert_equal(nil, PRUNE::Message.channelinfo(:whowas))
    541. 

  541.     assert_equal(nil, PRUNE::Message.channelinfo("foo"))
    542. 

  542.     assert_equal(nil, PRUNE::Message.channelinfo(:foo))
    543. 

  543.     assert_equal(nil, PRUNE::Message.channelinfo("001"))
    544. 

  544.     assert_equal(nil, PRUNE::Message.channelinfo("002"))
    545. 

  545.     assert_equal(nil, PRUNE::Message.channelinfo("003"))
    546. 

  546.     assert_equal(nil, PRUNE::Message.channelinfo("004"))
    547. 

  547.     assert_equal(nil, PRUNE::Message.channelinfo("005"))
    548. 

  548.     assert_equal(nil, PRUNE::Message.channelinfo("200"))
    549. 

  549.     assert_equal(nil, PRUNE::Message.channelinfo("201"))
    550. 

  550.     assert_equal(nil, PRUNE::Message.channelinfo("202"))
    551. 

  551.     assert_equal(nil, PRUNE::Message.channelinfo("203"))
    552. 

  552.     assert_equal(nil, PRUNE::Message.channelinfo("204"))
    553. 

  553.     assert_equal(nil, PRUNE::Message.channelinfo("205"))
    554. 

  554.     assert_equal(nil, PRUNE::Message.channelinfo("206"))
    555. 

  555.     assert_equal(nil, PRUNE::Message.channelinfo("207"))
    556. 

  556.     assert_equal(nil, PRUNE::Message.channelinfo("208"))
    557. 

  557.     assert_equal(nil, PRUNE::Message.channelinfo("209"))
    558. 

  558.     assert_equal(nil, PRUNE::Message.channelinfo("210"))
    559. 

  559.     assert_equal(nil, PRUNE::Message.channelinfo("211"))
    560. 

  560.     assert_equal(nil, PRUNE::Message.channelinfo("212"))
    561. 

  561.     assert_equal(nil, PRUNE::Message.channelinfo("213"))
    562. 

  562.     assert_equal(nil, PRUNE::Message.channelinfo("214"))
    563. 

  563.     assert_equal(nil, PRUNE::Message.channelinfo("215"))
    564. 

  564.     assert_equal(nil, PRUNE::Message.channelinfo("216"))
    565. 

  565.     assert_equal(nil, PRUNE::Message.channelinfo("217"))
    566. 

  566.     assert_equal(nil, PRUNE::Message.channelinfo("218"))
    567. 

  567.     assert_equal(nil, PRUNE::Message.channelinfo("219"))
    568. 

  568.     assert_equal(nil, PRUNE::Message.channelinfo("220"))
    569. 

  569.     assert_equal(nil, PRUNE::Message.channelinfo("221"))
    570. 

  570.     assert_equal(nil, PRUNE::Message.channelinfo("231"))
    571. 

  571.     assert_equal(nil, PRUNE::Message.channelinfo("232"))
    572. 

  572.     assert_equal(nil, PRUNE::Message.channelinfo("233"))
    573. 

  573.     assert_equal(nil, PRUNE::Message.channelinfo("234"))
    574. 

  574.     assert_equal(nil, PRUNE::Message.channelinfo("235"))
    575. 

  575.     assert_equal(nil, PRUNE::Message.channelinfo("240"))
    576. 

  576.     assert_equal(nil, PRUNE::Message.channelinfo("241"))
    577. 

  577.     assert_equal(nil, PRUNE::Message.channelinfo("242"))
    578. 

  578.     assert_equal(nil, PRUNE::Message.channelinfo("243"))
    579. 

  579.     assert_equal(nil, PRUNE::Message.channelinfo("244"))
    580. 

  580.     assert_equal(nil, PRUNE::Message.channelinfo("245"))
    581. 

  581.     assert_equal(nil, PRUNE::Message.channelinfo("246"))
    582. 

  582.     assert_equal(nil, PRUNE::Message.channelinfo("247"))
    583. 

  583.     assert_equal(nil, PRUNE::Message.channelinfo("248"))
    584. 

  584.     assert_equal(nil, PRUNE::Message.channelinfo("249"))
    585. 

  585.     assert_equal(nil, PRUNE::Message.channelinfo("250"))
    586. 

  586.     assert_equal(nil, PRUNE::Message.channelinfo("251"))
    587. 

  587.     assert_equal(nil, PRUNE::Message.channelinfo("252"))
    588. 

  588.     assert_equal(nil, PRUNE::Message.channelinfo("253"))
    589. 

  589.     assert_equal(nil, PRUNE::Message.channelinfo("254"))
    590. 

  590.     assert_equal(nil, PRUNE::Message.channelinfo("255"))
    591. 

  591.     assert_equal(nil, PRUNE::Message.channelinfo("256"))
    592. 

  592.     assert_equal(nil, PRUNE::Message.channelinfo("257"))
    593. 

  593.     assert_equal(nil, PRUNE::Message.channelinfo("258"))
    594. 

  594.     assert_equal(nil, PRUNE::Message.channelinfo("259"))
    595. 

  595.     assert_equal(nil, PRUNE::Message.channelinfo("260"))
    596. 

  596.     assert_equal(nil, PRUNE::Message.channelinfo("261"))
    597. 

  597.     assert_equal(nil, PRUNE::Message.channelinfo("262"))
    598. 

  598.     assert_equal(nil, PRUNE::Message.channelinfo("263"))
    599. 

  599.     assert_equal(nil, PRUNE::Message.channelinfo("264"))
    600. 

  600.     assert_equal(nil, PRUNE::Message.channelinfo("265"))
    601. 

  601.     assert_equal(nil, PRUNE::Message.channelinfo("266"))
    602. 

  602.     assert_equal(nil, PRUNE::Message.channelinfo("300"))
    603. 

  603.     assert_equal(nil, PRUNE::Message.channelinfo("301"))
    604. 

  604.     assert_equal(nil, PRUNE::Message.channelinfo("302"))
    605. 

  605.     assert_equal(nil, PRUNE::Message.channelinfo("303"))
    606. 

  606.     assert_equal(nil, PRUNE::Message.channelinfo("304"))
    607. 

  607.     assert_equal(nil, PRUNE::Message.channelinfo("305"))
    608. 

  608.     assert_equal(nil, PRUNE::Message.channelinfo("306"))
    609. 

  609.     assert_equal(nil, PRUNE::Message.channelinfo("311"))
    610. 

  610.     assert_equal(nil, PRUNE::Message.channelinfo("312"))
    611. 

  611.     assert_equal(nil, PRUNE::Message.channelinfo("313"))
    612. 

  612.     assert_equal(nil, PRUNE::Message.channelinfo("314"))
    613. 

  613.     assert_not_nil(PRUNE::Message.channelinfo("315"))
    614. 

  614.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("315").location)
    615. 

  615.     assert_equal(1, PRUNE::Message.channelinfo("315").index)
    616. 

  616.     assert_equal(nil, PRUNE::Message.channelinfo("316"))
    617. 

  617.     assert_equal(nil, PRUNE::Message.channelinfo("317"))
    618. 

  618.     assert_equal(nil, PRUNE::Message.channelinfo("318"))
    619. 

  619.     assert_equal(nil, PRUNE::Message.channelinfo("319"))
    620. 

  620.     assert_equal(nil, PRUNE::Message.channelinfo("320"))
    621. 

  621.     assert_equal(nil, PRUNE::Message.channelinfo("321"))
    622. 

  622.     assert_not_nil(PRUNE::Message.channelinfo("322"))
    623. 

  623.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("322").location)
    624. 

  624.     assert_equal(1, PRUNE::Message.channelinfo("322").index)
    625. 

  625.     assert_equal(nil, PRUNE::Message.channelinfo("323"))
    626. 

  626.     assert_not_nil(PRUNE::Message.channelinfo("324"))
    627. 

  627.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("324").location)
    628. 

  628.     assert_equal(1, PRUNE::Message.channelinfo("324").index)
    629. 

  629.     assert_equal(nil, PRUNE::Message.channelinfo("325"))
    630. 

  630.     assert_not_nil(PRUNE::Message.channelinfo("329"))
    631. 

  631.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("329").location)
    632. 

  632.     assert_equal(1, PRUNE::Message.channelinfo("329").index)
    633. 

  633.     assert_equal(nil, PRUNE::Message.channelinfo("330"))
    634. 

  634.     assert_equal(nil, PRUNE::Message.channelinfo("331"))
    635. 

  635.     assert_not_nil(PRUNE::Message.channelinfo("332"))
    636. 

  636.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("332").location)
    637. 

  637.     assert_equal(1, PRUNE::Message.channelinfo("332").index)
    638. 

  638.     assert_not_nil(PRUNE::Message.channelinfo("333"))
    639. 

  639.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("333").location)
    640. 

  640.     assert_equal(1, PRUNE::Message.channelinfo("333").index)
    641. 

  641.     assert_not_nil(PRUNE::Message.channelinfo("341"))
    642. 

  642.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("341").location)
    643. 

  643.     assert_equal(2, PRUNE::Message.channelinfo("341").index)
    644. 

  644.     assert_equal(nil, PRUNE::Message.channelinfo("342"))
    645. 

  645.     assert_equal(nil, PRUNE::Message.channelinfo("346"))
    646. 

  646.     assert_equal(nil, PRUNE::Message.channelinfo("347"))
    647. 

  647.     assert_equal(nil, PRUNE::Message.channelinfo("348"))
    648. 

  648.     assert_equal(nil, PRUNE::Message.channelinfo("349"))
    649. 

  649.     assert_equal(nil, PRUNE::Message.channelinfo("350"))
    650. 

  650.     assert_equal(nil, PRUNE::Message.channelinfo("351"))
    651. 

  651.     assert_not_nil(PRUNE::Message.channelinfo("352"))
    652. 

  652.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("352").location)
    653. 

  653.     assert_equal(1, PRUNE::Message.channelinfo("352").index)
    654. 

  654.     assert_not_nil(PRUNE::Message.channelinfo("353"))
    655. 

  655.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("353").location)
    656. 

  656.     assert_equal(2, PRUNE::Message.channelinfo("353").index)
    657. 

  657.     assert_equal(nil, PRUNE::Message.channelinfo("361"))
    658. 

  658.     assert_equal(nil, PRUNE::Message.channelinfo("362"))
    659. 

  659.     assert_equal(nil, PRUNE::Message.channelinfo("363"))
    660. 

  660.     assert_equal(nil, PRUNE::Message.channelinfo("364"))
    661. 

  661.     assert_equal(nil, PRUNE::Message.channelinfo("365"))
    662. 

  662.     assert_not_nil(PRUNE::Message.channelinfo("366"))
    663. 

  663.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("366").location)
    664. 

  664.     assert_equal(1, PRUNE::Message.channelinfo("366").index)
    665. 

  665.     assert_not_nil(PRUNE::Message.channelinfo("367"))
    666. 

  666.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("367").location)
    667. 

  667.     assert_equal(1, PRUNE::Message.channelinfo("367").index)
    668. 

  668.     assert_not_nil(PRUNE::Message.channelinfo("368"))
    669. 

  669.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("368").location)
    670. 

  670.     assert_equal(1, PRUNE::Message.channelinfo("368").index)
    671. 

  671.     assert_equal(nil, PRUNE::Message.channelinfo("369"))
    672. 

  672.     assert_equal(nil, PRUNE::Message.channelinfo("370"))
    673. 

  673.     assert_equal(nil, PRUNE::Message.channelinfo("371"))
    674. 

  674.     assert_equal(nil, PRUNE::Message.channelinfo("372"))
    675. 

  675.     assert_equal(nil, PRUNE::Message.channelinfo("373"))
    676. 

  676.     assert_equal(nil, PRUNE::Message.channelinfo("374"))
    677. 

  677.     assert_equal(nil, PRUNE::Message.channelinfo("375"))
    678. 

  678.     assert_equal(nil, PRUNE::Message.channelinfo("376"))
    679. 

  679.     assert_equal(nil, PRUNE::Message.channelinfo("381"))
    680. 

  680.     assert_equal(nil, PRUNE::Message.channelinfo("382"))
    681. 

  681.     assert_equal(nil, PRUNE::Message.channelinfo("383"))
    682. 

  682.     assert_equal(nil, PRUNE::Message.channelinfo("384"))
    683. 

  683.     assert_equal(nil, PRUNE::Message.channelinfo("391"))
    684. 

  684.     assert_equal(nil, PRUNE::Message.channelinfo("392"))
    685. 

  685.     assert_equal(nil, PRUNE::Message.channelinfo("393"))
    686. 

  686.     assert_equal(nil, PRUNE::Message.channelinfo("394"))
    687. 

  687.     assert_equal(nil, PRUNE::Message.channelinfo("395"))
    688. 

  688.     assert_equal(nil, PRUNE::Message.channelinfo("-1"))
    689. 

  689.     assert_equal(nil, PRUNE::Message.channelinfo("401"))
    690. 

  690.     assert_equal(nil, PRUNE::Message.channelinfo("402"))
    691. 

  691.     assert_not_nil(PRUNE::Message.channelinfo("403"))
    692. 

  692.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("403").location)
    693. 

  693.     assert_equal(1, PRUNE::Message.channelinfo("403").index)
    694. 

  694.     assert_not_nil(PRUNE::Message.channelinfo("404"))
    695. 

  695.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("404").location)
    696. 

  696.     assert_equal(1, PRUNE::Message.channelinfo("404").index)
    697. 

  697.     assert_not_nil(PRUNE::Message.channelinfo("405"))
    698. 

  698.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("405").location)
    699. 

  699.     assert_equal(1, PRUNE::Message.channelinfo("405").index)
    700. 

  700.     assert_equal(nil, PRUNE::Message.channelinfo("406"))
    701. 

  701.     assert_equal(nil, PRUNE::Message.channelinfo("407"))
    702. 

  702.     assert_equal(nil, PRUNE::Message.channelinfo("408"))
    703. 

  703.     assert_equal(nil, PRUNE::Message.channelinfo("409"))
    704. 

  704.     assert_equal(nil, PRUNE::Message.channelinfo("410"))
    705. 

  705.     assert_equal(nil, PRUNE::Message.channelinfo("411"))
    706. 

  706.     assert_equal(nil, PRUNE::Message.channelinfo("412"))
    707. 

  707.     assert_equal(nil, PRUNE::Message.channelinfo("413"))
    708. 

  708.     assert_equal(nil, PRUNE::Message.channelinfo("414"))
    709. 

  709.     assert_equal(nil, PRUNE::Message.channelinfo("415"))
    710. 

  710.     assert_equal(nil, PRUNE::Message.channelinfo("421"))
    711. 

  711.     assert_equal(nil, PRUNE::Message.channelinfo("422"))
    712. 

  712.     assert_equal(nil, PRUNE::Message.channelinfo("423"))
    713. 

  713.     assert_equal(nil, PRUNE::Message.channelinfo("424"))
    714. 

  714.     assert_equal(nil, PRUNE::Message.channelinfo("431"))
    715. 

  715.     assert_equal(nil, PRUNE::Message.channelinfo("432"))
    716. 

  716.     assert_equal(nil, PRUNE::Message.channelinfo("433"))
    717. 

  717.     assert_equal(nil, PRUNE::Message.channelinfo("434"))
    718. 

  718.     assert_equal(nil, PRUNE::Message.channelinfo("435"))
    719. 

  719.     assert_equal(nil, PRUNE::Message.channelinfo("436"))
    720. 

  720.     assert_not_nil(PRUNE::Message.channelinfo("437"))
    721. 

  721.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("437").location)
    722. 

  722.     assert_equal(1, PRUNE::Message.channelinfo("437").index)
    723. 

  723.     assert_not_nil(PRUNE::Message.channelinfo("441"))
    724. 

  724.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("441").location)
    725. 

  725.     assert_equal(2, PRUNE::Message.channelinfo("441").index)
    726. 

  726.     assert_not_nil(PRUNE::Message.channelinfo("442"))
    727. 

  727.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("442").location)
    728. 

  728.     assert_equal(1, PRUNE::Message.channelinfo("442").index)
    729. 

  729.     assert_not_nil(PRUNE::Message.channelinfo("443"))
    730. 

  730.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("443").location)
    731. 

  731.     assert_equal(2, PRUNE::Message.channelinfo("443").index)
    732. 

  732.     assert_equal(nil, PRUNE::Message.channelinfo("444"))
    733. 

  733.     assert_equal(nil, PRUNE::Message.channelinfo("445"))
    734. 

  734.     assert_equal(nil, PRUNE::Message.channelinfo("446"))
    735. 

  735.     assert_equal(nil, PRUNE::Message.channelinfo("451"))
    736. 

  736.     assert_equal(nil, PRUNE::Message.channelinfo("461"))
    737. 

  737.     assert_equal(nil, PRUNE::Message.channelinfo("462"))
    738. 

  738.     assert_equal(nil, PRUNE::Message.channelinfo("463"))
    739. 

  739.     assert_equal(nil, PRUNE::Message.channelinfo("464"))
    740. 

  740.     assert_equal(nil, PRUNE::Message.channelinfo("465"))
    741. 

  741.     assert_equal(nil, PRUNE::Message.channelinfo("466"))
    742. 

  742.     assert_not_nil(PRUNE::Message.channelinfo("467"))
    743. 

  743.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("467").location)
    744. 

  744.     assert_equal(1, PRUNE::Message.channelinfo("467").index)
    745. 

  745.     assert_equal(nil, PRUNE::Message.channelinfo("468"))
    746. 

  746.     assert_not_nil(PRUNE::Message.channelinfo("471"))
    747. 

  747.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("471").location)
    748. 

  748.     assert_equal(1, PRUNE::Message.channelinfo("471").index)
    749. 

  749.     assert_equal(nil, PRUNE::Message.channelinfo("472"))
    750. 

  750.     assert_not_nil(PRUNE::Message.channelinfo("473"))
    751. 

  751.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("473").location)
    752. 

  752.     assert_equal(1, PRUNE::Message.channelinfo("473").index)
    753. 

  753.     assert_not_nil(PRUNE::Message.channelinfo("474"))
    754. 

  754.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("474").location)
    755. 

  755.     assert_equal(1, PRUNE::Message.channelinfo("474").index)
    756. 

  756.     assert_not_nil(PRUNE::Message.channelinfo("475"))
    757. 

  757.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("475").location)
    758. 

  758.     assert_equal(1, PRUNE::Message.channelinfo("475").index)
    759. 

  759.     assert_not_nil(PRUNE::Message.channelinfo("476"))
    760. 

  760.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("476").location)
    761. 

  761.     assert_equal(1, PRUNE::Message.channelinfo("476").index)
    762. 

  762.     assert_not_nil(PRUNE::Message.channelinfo("477"))
    763. 

  763.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("477").location)
    764. 

  764.     assert_equal(1, PRUNE::Message.channelinfo("477").index)
    765. 

  765.     assert_not_nil(PRUNE::Message.channelinfo("478"))
    766. 

  766.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("478").location)
    767. 

  767.     assert_equal(1, PRUNE::Message.channelinfo("478").index)
    768. 

  768.     assert_equal(nil, PRUNE::Message.channelinfo("479"))
    769. 

  769.     assert_equal(nil, PRUNE::Message.channelinfo("480"))
    770. 

  770.     assert_equal(nil, PRUNE::Message.channelinfo("481"))
    771. 

  771.     assert_not_nil(PRUNE::Message.channelinfo("482"))
    772. 

  772.     assert_equal(PRUNE::Message::CH_PARAM, PRUNE::Message.channelinfo("482").location)
    773. 

  773.     assert_equal(1, PRUNE::Message.channelinfo("482").index)
    774. 

  774.     assert_equal(nil, PRUNE::Message.channelinfo("483"))
    775. 

  775.     assert_equal(nil, PRUNE::Message.channelinfo("484"))
    776. 

  776.     assert_equal(nil, PRUNE::Message.channelinfo("485"))
    777. 

  777.     assert_equal(nil, PRUNE::Message.channelinfo("491"))
    778. 

  778.     assert_equal(nil, PRUNE::Message.channelinfo("492"))
    779. 

  779.     assert_equal(nil, PRUNE::Message.channelinfo("501"))
    780. 

  780.     assert_equal(nil, PRUNE::Message.channelinfo("502"))
    781. 

  781.     assert_equal(nil, PRUNE::Message.channelinfo(1))
    782. 

  782.   end # def test_channelinfo
    783. 

  783. 

  784.   def test_validate_command_
    785. 

  785.     assert_equal(false, PRUNE::Message.valid_command?("foo"))
    786. 

  786.     assert_equal(true, PRUNE::Message.valid_command?("connect"))
    787. 

  787.     assert_equal(true, PRUNE::Message.valid_command?("Connect"))
    788. 

  788.     assert_equal(true, PRUNE::Message.valid_command?(:connect))
    789. 

  789.     assert_equal(true, PRUNE::Message.valid_command?(:die))
    790. 

  790.     assert_equal(true, PRUNE::Message.valid_command?(:error))
    791. 

  791.     assert_equal(true, PRUNE::Message.valid_command?(:ping))
    792. 

  792.     assert_equal(true, PRUNE::Message.valid_command?(:pong))
    793. 

  793.     assert_equal(true, PRUNE::Message.valid_command?(:rehash))
    794. 

  794.     assert_equal(true, PRUNE::Message.valid_command?(:restart))
    795. 

  795.     assert_equal(true, PRUNE::Message.valid_command?(:service))
    796. 

  796.     assert_equal(true, PRUNE::Message.valid_command?(:squit))
    797. 

  797.     assert_equal(true, PRUNE::Message.valid_command?(:trace))
    798. 

  798.     assert_equal(true, PRUNE::Message.valid_command?(:wallops))
    799. 

  799.     assert_equal(true, PRUNE::Message.valid_command?(:admin))
    800. 

  800.     assert_equal(true, PRUNE::Message.valid_command?(:away))
    801. 

  801.     assert_equal(true, PRUNE::Message.valid_command?(:info))
    802. 

  802.     assert_equal(true, PRUNE::Message.valid_command?(:links))
    803. 

  803.     assert_equal(true, PRUNE::Message.valid_command?(:list))
    804. 

  804.     assert_equal(true, PRUNE::Message.valid_command?(:lusers))
    805. 

  805.     assert_equal(true, PRUNE::Message.valid_command?(:motd))
    806. 

  806.     assert_equal(true, PRUNE::Message.valid_command?(:oper))
    807. 

  807.     assert_equal(true, PRUNE::Message.valid_command?(:pass))
    808. 

  808.     assert_equal(true, PRUNE::Message.valid_command?(:quit))
    809. 

  809.     assert_equal(true, PRUNE::Message.valid_command?(:servlist))
    810. 

  810.     assert_equal(true, PRUNE::Message.valid_command?(:squery))
    811. 

  811.     assert_equal(true, PRUNE::Message.valid_command?(:stats))
    812. 

  812.     assert_equal(true, PRUNE::Message.valid_command?(:time))
    813. 

  813.     assert_equal(true, PRUNE::Message.valid_command?(:user))
    814. 

  814.     assert_equal(true, PRUNE::Message.valid_command?(:users))
    815. 

  815.     assert_equal(true, PRUNE::Message.valid_command?(:version))
    816. 

  816.     assert_equal(true, PRUNE::Message.valid_command?(:invite))
    817. 

  817.     assert_equal(true, PRUNE::Message.valid_command?(:ison))
    818. 

  818.     assert_equal(true, PRUNE::Message.valid_command?(:join))
    819. 

  819.     assert_equal(true, PRUNE::Message.valid_command?(:ki…
    820.