From bb94e44ed6ec5b55823270192c00904cbfb24b6b Mon Sep 17 00:00:00 2001 From: Till Hoeppner Date: Sat, 18 Apr 2015 13:35:38 +0200 Subject: I forgot to keep track. Embarassing, huh? --- src/message.rs | 658 +++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 527 insertions(+), 131 deletions(-) (limited to 'src/message.rs') diff --git a/src/message.rs b/src/message.rs index edc1874..4adc83a 100644 --- a/src/message.rs +++ b/src/message.rs @@ -1,183 +1,258 @@ #![allow(non_camel_case_types)] use std::str::FromStr; -use std::borrow::ToOwned; - -#[derive(Clone)] -pub struct Message { - pub prefix: Option, - pub command: Command, - pub content: Vec, - pub suffix: Option +use std::string::{ ToString }; +use std::borrow::{ Cow, ToOwned }; + +#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] +pub enum MsgType { + /// Plain old IRC messages, as defined in [rfc2812][rfc] + /// rfc: http://tools.ietf.org/html/rfc2812 + Irc, + /// Ctcp messages, wrapped in \u{1} + Ctcp +} + +#[derive(Debug, PartialEq, Eq, Hash, Clone)] +pub struct Message<'a> { + pub prefix: Option>, + pub command: Cow<'a, String>, + pub content: Vec>, + pub suffix: Option>, + pub msg_type: MsgType } -impl Message { - pub fn new(prefix: Option, command: Command, content: Vec, suffix: Option) -> Message { +impl<'a> Message<'a> { + pub fn new(prefix: Option>, command: Cow<'a, String>, content: Vec>, suffix: Option>, msg_type: MsgType) -> Message<'a> { Message { prefix: prefix, command: command, content: content, - suffix: suffix + suffix: suffix, + msg_type: msg_type } } +} - pub fn parse(i: &str) -> Option { +impl<'a> FromStr for Message<'a> { + type Err = ::IrscError; + fn from_str(i: &str) -> Result, ::IrscError> { + info!("Attempting to parse message: {}", i); let len = i.len(); let mut s = i; + + let msg_type = if s.char_at(0) == '\u{1}' { MsgType::Ctcp } else { MsgType::Irc }; + let prefix = if len >= 1 && s.char_at(0) == ':' { s.find(' ').map(|i| { let p = s.slice_chars(1, i).to_owned(); - s = s[i..]; + s = &s[i + 1..]; p }) } else { None }; let command = s.find(' ').map(|i| { let p = s.slice_chars(0, i).to_owned(); - s = s[i..]; + s = &s[i..]; p - }).and_then(|c| c.parse()); + }).map(|c| c.parse()).map(|c| Some(Cow::Owned(c))); + // TODO: Parse last non-suffix argument as suffix if no suffix + // with colon is available. let mut content = Vec::with_capacity(15); let mut suffix = None; while s.len() > 0 { if s.char_at(0) == ':' { - suffix = Some(s.slice_from(1).to_owned()); + suffix = Some(s[1..].to_owned()); break } s.find(' ').map(|i| { - content.push(s.slice_chars(0, i).to_owned()); - s = s[i..]; + if i > 0 { + content.push(Cow::Owned(s.slice_chars(0, i).to_owned())); + s = &s[i..]; + } }); + if s.char_at(0) == ' ' { s = &s[1..] }; } - command.map(move |c| Message::new(prefix, c, content, suffix)) + command.and_then(move |Ok(c)| + Ok(Message::new(prefix.map(|p| Cow::Owned(p)), + c, + content, + suffix.map(|s| Cow::Owned(s)), + msg_type + )) + ) + } +} - pub fn format(&self) -> String { +impl<'a> ToString for Message<'a> { + fn to_string(&self) -> String { let mut s = String::with_capacity(512); if let Some(ref p) = self.prefix { s.push(':'); - s.push_str(p[]); + s.push_str(&p); s.push(' '); } - s.push_str(format!("{} ", self.command)[]); + s.push_str(&self.command); + s.push(' '); + + for part in self.content.iter() { + s.push_str(&part); + s.push(' '); + } if let Some(ref p) = self.suffix { s.push(':'); - s.push_str(p[]); + s.push_str(&p); } s + } } -#[derive(Copy, Clone, Show, PartialEq, Eq, Hash)] -pub enum Command { - PASS, - NICK, - USER, - OPER, - MODE, - SERVICE, - QUIT, - SQUIT, - JOIN, - PART, - TOPIC, - NAMES, - LIST, - INVITE, - KICK, - PRIVMSG, - NOTICE, - MOTD, - LUSERS, - VERSION, - STATS, - LINKS, - TIME, - CONNECT, - TRACE, - ADMIN, - INFO, - SERVLIST, - SQUERY, - WHO, - WHOIS, - WHOWAS, - KILL, - PING, - PONG, - ERROR, - AWAY, - REHASH, - DIE, - RESTART, - SUMMON, - USERS, - WALLOPS, - USERHOST, - ISON +/* +pub trait Command { + fn name(&self) -> String; + fn to_message(&self) -> Message; + fn from_message(msg: &Message) -> Option } -impl FromStr for Command { - fn from_str(s: &str) -> Option { - use self::Command::*; - match s { - "PASS" => Some(PASS), - "NICK" => Some(NICK), - "USER" => Some(USER), - "OPER" => Some(OPER), - "MODE" => Some(MODE), - "SERVICE" => Some(SERVICE), - "QUIT" => Some(QUIT), - "SQUIT" => Some(SQUIT), - "JOIN" => Some(JOIN), - "PART" => Some(PART), - "TOPIC" => Some(TOPIC), - "NAMES" => Some(NAMES), - "LIST" => Some(LIST), - "INVITE" => Some(INVITE), - "KICK" => Some(KICK), - "PRIVMSG" => Some(PRIVMSG), - "NOTICE" => Some(NOTICE), - "MOTD" => Some(MOTD), - "LUSERS" => Some(LUSERS), - "VERSION" => Some(VERSION), - "STATS" => Some(STATS), - "LINKS" => Some(LINKS), - "TIME" => Some(TIME), - "CONNECT" => Some(CONNECT), - "TRACE" => Some(TRACE), - "ADMIN" => Some(ADMIN), - "INFO" => Some(INFO), - "SERVLIST" => Some(SERVLIST), - "SQUERY" => Some(SQUERY), - "WHO" => Some(WHO), - "WHOIS" => Some(WHOIS), - "WHOWAS" => Some(WHOWAS), - "KILL" => Some(KILL), - "PING" => Some(PING), - "PONG" => Some(PONG), - "ERROR" => Some(ERROR), - "AWAY" => Some(AWAY), - "REHASH" => Some(REHASH), - "DIE" => Some(DIE), - "RESTART" => Some(RESTART), - "SUMMON" => Some(SUMMON), - "USERS" => Some(USERS), - "WALLOPS" => Some(WALLOPS), - "USERHOST" => Some(USERHOST), - "ISON" => Some(ISON), - _ => None +macro_rules! command ( + ($name: ident { $($field: ident: $t: ty),* } to $to_msg: expr; from $from_msg: expr;) => ( + pub struct $name { + $(pub $field: $t),* } - } + + impl Command for $name { + fn name(&self) -> String { stringify!($name).to_owned() } + fn to_message(&self) -> Message { ($to_msg)(self) } + fn from_message(msg: &Message) -> Option<$name> { ($from_msg)(msg) } + } + ) +);*/ + +/* +command!(Pass { password: String } + to |&:s: &Pass| Message::new(None, "PASS".to_owned(), Vec::new(), Some(s.password.clone())); + from |&:msg: &Message| msg.clone().suffix.map(|s| Pass { password: s });); + +command!(Ping { server1: Option, server2: Option } + to |&:s :&Ping| { + let mut v = Vec::new(); + if let Some(ref s) = s.server1 { v.push(s.clone()) } + if let Some(ref s) = s.server2 { v.push(s.clone()) } + Message::new(None, "PING".to_owned(), v, None) + }; + from |&:msg: &Message| { + let mut c = msg.content.clone(); + Some(Ping { server2: c.pop(), server1: c.pop() }) }; ); + +command!(Pong { server1: Option, server2: Option } + to |&:s: &Pong| { + let mut v = Vec::new(); + if let Some(ref s) = s.server1 { v.push(s.clone()) } + if let Some(ref s) = s.server2 { v.push(s.clone()) } + Message::new(None, "PONG".to_owned(), v, None) + }; + from |&:msg: &Message| { + let mut c = msg.content.clone(); + Some(Pong { server2: c.pop(), server1: c.pop() }) + }; ); + +command!(PrivMsg { from: Option, to: String, content: String } + to |&:s: &PrivMsg| { + Message::new(s.from.clone(), "PRIVMSG".to_owned(), vec![s.to.clone()], Some(s.content.clone())) + }; + from |&:msg: &Message| { + msg.content.clone().pop().map( + |c| PrivMsg { + from: msg.prefix.clone(), + to: c, + content: msg.suffix.clone().unwrap_or(String::new()) + }) + }; ); +*/ + +#[derive(Clone, PartialEq, Eq, Hash)] +pub enum Mode { + Away, + Invisible, + Wallops, + Restricted, + Operator, + LocalOperator, + ServerNotices, + Custom(String) } -#[derive(Show, Copy, PartialEq, Eq)] -pub enum Response { +#[derive(Copy, Clone, PartialEq, Eq, Hash)] +pub enum SetMode { + Plus, + Minus +} + +#[derive(Clone, PartialEq, Eq, Hash)] +pub enum Command<'a> { + Pass { password: Cow<'a, String> }, + Nick { nickname: Cow<'a, String> }, + User { user: Cow<'a, String>, mode: Cow<'a, String>, unused: Cow<'a, String>, realname: Cow<'a, String> }, + Oper { name: Cow<'a, String>, password: Cow<'a, String> }, + Mode { nickname: Cow<'a, String>, mode: &'a [(SetMode, Mode)] }, + Service { nickname: Cow<'a, String>, reserved: Cow<'a, String>, distribution: Cow<'a, String>, service_type: Cow<'a, String>, reserved2: Cow<'a, String>, info: Cow<'a, String> }, + Quit { message: Option> }, + SQuit { server: Cow<'a, String>, comment: Cow<'a, String> }, + Join { channels: &'a [(Cow<'a, String>, Option>)] }, + Join_leave_all, + Part { channels: &'a [Cow<'a, String>], message: Cow<'a, String> }, + /* + Topic = 1011, + Names = 1012, + List = 1013, + Invite = 1014, + Kick = 1015, + */ + PrivMsg { from: Option>, to: Cow<'a, String>, content: Cow<'a, String> }, + Notice { to: Cow<'a, String>, content: Cow<'a, String> }, + /* + Motd = 1018, + LUsers = 1019, + Version = 1020, + Stats = 1021, + Links = 1022, + Time = 1023, + Connect = 1024, + Trace = 1025, + Admin = 1026, + Info = 1027, + ServList = 1028, + SQuery = 1029, + Who = 1030, + WhoIs = 1031, + WhoWas = 1032, + Kill = 1033, + */ + Ping { server1: Option>, server2: Option> }, + Pong { server1: Option>, server2: Option> }, + /* + Error = 1036, + Away = 1037, + Rehash = 1038, + Die = 1039, + Restart = 1040, + Summon = 1041, + Users = 1042, + Wallops = 1043, + Userhost = 1044, + Ison = 1045,*/ + + Ctcp { command: Cow<'a, String> }, + + /* + /// "Welcome to the Internet Relay Network !@" RPL_WELCOME = 001, /// "Your host is , running version " @@ -678,12 +753,12 @@ pub enum Response { /// ":USERS has been disabled" /// - Returned as a response to the USERS command. MUST be /// returned by any server which does not implement it. - ERR_USERSDISABLED = 446, + ERR_USERSDISABLED = 446,*/ /// ":You have not registered" /// - Returned by the server to indicate that the client /// MUST be registered before the server will allow it /// to be parsed in detail. - ERR_NOTREGISTERED = 451, + ErrNotRegistered,/* /// " :Not enough parameters" /// - Returned by the server by numerous commands to /// indicate to the client that it didn't supply enough @@ -770,17 +845,305 @@ pub enum Response { /// ":Cannot change mode for other users" /// - Error sent to any user trying to view or change the /// user mode for a user other than themselves. - ERR_USERSDONTMATCH = 502, + ERR_USERSDONTMATCH = 502 + */ } -impl Response { - pub fn is_reply(&self) -> bool { let i = *self as uint; i >= 200 && i <= 399 } - pub fn is_error(&self) -> bool { let i = *self as uint; i >= 400 && i <= 599 } +/* +impl ToString for Command { + fn to_string(&self) -> String { + match self { + PASS => "PING", + NICK => "NICK", + USER => "USER", + OPER => "1004", + MODE => "1005", + SERVICE => "1006", + QUIT => "1007", + SQUIT => "1008", + JOIN => "1009", + PART => "1010", + TOPIC => "1011", + NAMES => "1012", + LIST => "1013", + INVITE => "1014", + KICK => "1015", + PRIVMSG => "1016", + NOTICE => "1017", + MOTD => "1018", + LUSERS => "1019", + VERSION => "1020", + STATS => "1021", + LINKS => "1022", + TIME => "1023", + CONNECT => "1024", + TRACE => "1025", + ADMIN => "1026", + INFO => "1027", + SERVLIST => "1028", + SQUERY => "1029", + WHO => "1030", + WHOIS => "1031", + WHOWAS => "1032", + KILL => "1033", + PING => "1034", + PONG => "1035", + ERROR => "1036", + AWAY => "1037", + REHASH => "1038", + DIE => "1039", + RESTART => "1040", + SUMMON => "1041", + USERS => "1042", + WALLOPS => "1043", + USERHOST => "1044", + ISON => "1045", + + RPL_WELCOME => "001", + RPL_YOURHOST => "002", + RPL_CREATED => "003", + RPL_MYINFO => "004", + RPL_BOUNCE => "005", + RPL_USERHOST => "302", + RPL_ISON => "303", + RPL_AWAY => "301", + RPL_UNAWAY => "305", + RPL_NOWAWAY => "306", + RPL_WHOISUSER => "311", + RPL_WHOISSERVER => "312", + RPL_WHOISOPERATOR => "313", + RPL_WHOISIDLE => "317", + RPL_ENDOFWHOIS => "318", + RPL_WHOISCHANNELS => "319", + RPL_WHOWASUSER => "314", + RPL_ENDOFWHOWAS => "369", + RPL_LISTSTART => "321", + RPL_LIST => "322", + RPL_LISTEND => "323", + RPL_UNIQOPIS => "325", + RPL_CHANNELMODEIS => "324", + RPL_NOTOPIC => "331", + RPL_TOPIC => "332", + RPL_INVITING => "341", + RPL_SUMMONING => "342", + RPL_INVITELIST => "346", + RPL_ENDOFINVITELIST => "347", + RPL_EXCEPTLIST => "348", + RPL_ENDOFEXCEPTLIST => "349", + RPL_VERSION => "351", + RPL_WHOREPLY => "352", + RPL_ENDOFWHO => "315", + RPL_NAMREPLY => "353", + RPL_ENDOFNAMES => "366", + RPL_LINKS => "364", + RPL_ENDOFLINKS => "365", + RPL_BANLIST => "367", + RPL_ENDOFBANLIST => "368", + RPL_INFO => "371", + RPL_ENDOFINFO => "374", + RPL_MOTDSTART => "375", + RPL_MOTD => "372", + RPL_ENDOFMOTD => "376", + RPL_YOUREOPER => "381", + RPL_REHASHING => "382", + RPL_YOURESERVICE => "383", + RPL_TIME => "391", + RPL_USERSSTART => "392", + RPL_USERS => "393", + RPL_ENDOFUSERS => "394", + RPL_NOUSERS => "395", + RPL_TRACELINK => "200", + RPL_TRACECONNECTING => "201", + RPL_TRACEHANDSHAKE => "202", + RPL_TRACEUNKNOWN => "203", + RPL_TRACEOPERATOR => "204", + RPL_TRACEUSER => "205", + RPL_TRACESERVER => "206", + RPL_TRACESERVICE => "207", + RPL_TRACENEWTYPE => "208", + RPL_TRACECLASS => "209", + RPL_TRACERECONNECT => "210", + RPL_TRACELOG => "261", + RPL_TRACEEND => "262", + RPL_STATSLINKINFO => "211", + RPL_STATSCOMMAND => "212", + RPL_ENDOFSTATS => "219", + RPL_STATSUPTIME => "242", + RPL_STATSOLINE => "243", + RPL_UMODEIS => "221", + RPL_SERVLIST => "234", + RPL_SERVLISTEND => "235", + RPL_LUSERCLIENT => "251", + RPL_LUSEROP => "252", + RPL_LUSERUNKNOWN => "253", + RPL_LUSERCHANNELS => "254", + RPL_LUSERME => "255", + RPL_ADMINME => "256", + RPL_ADMINLOC1 => "257", + RPL_ADMINLOC2 => "258", + RPL_ADMINEMAIL => "259", + RPL_TRYAGAIN => "263", + + ERR_NOSUCHNICK => "401", + ERR_NOSUCHSERVER => "402", + ERR_NOSUCHCHANNEL => "403", + ERR_CANNOTSENDTOCHAN => "404", + ERR_TOOMANYCHANNELS => "405", + ERR_WASNOSUCHNICK => "406", + ERR_TOOMANYTARGETS => "407", + ERR_NOSUCHSERVICE => "408", + ERR_NOORIGIN => "409", + ERR_NORECIPIENT => "411", + ERR_NOTEXTTOSEND => "412", + ERR_NOTOPLEVEL => "413", + ERR_WILDTOPLEVEL => "414", + ERR_BADMASK => "415", + ERR_UNKNOWNCOMMAND => "421", + ERR_NOMOTD => "422", + ERR_NOADMININFO => "423", + ERR_FILEERROR => "424", + ERR_NONICKNAMEGIVEN => "431", + ERR_ERRONEUSNICKNAME => "432", + ERR_NICKNAMEINUSE => "433", + ERR_NICKCOLLISION => "436", + ERR_UNAVAILRESOURCE => "437", + ERR_USERNOTINCHANNEL => "441", + ERR_NOTONCHANNEL => "442", + ERR_USERONCHANNEL => "443", + ERR_NOLOGIN => "444", + ERR_SUMMONDISABLED => "445", + ERR_USERSDISABLED => "446", + ERR_NOTREGISTERED => "451", + ERR_NEEDMOREPARAMS => "461", + ERR_ALREADYREGISTERED => "462", + ERR_NOPERMFORHOST => "463", + ERR_PASSWDMISMATCH => "464", + ERR_YOUREBANNEDCREEP => "465", + ERR_YOUWILLBEBANNED => "466", + ERR_KEYSET => "467", + ERR_CHANNELISFULL => "471", + ERR_UNKNOWNMODE => "472", + ERR_INVITEONLYCHAN => "473", + ERR_BANNEDFROMCHAN => "474", + ERR_BADCHANNELKEY => "475", + ERR_BADCHANMASK => "476", + ERR_NOCHANMODES => "477", + ERR_BANLISTFULL => "478", + ERR_NOPRIVILEGES => "481", + ERR_CHANOPRIVSNEEDED => "482", + ERR_CANTKILLSERVER => "483", + ERR_RESTRICTED => "484", + ERR_UNIQOPPRIVSNEEDED => "485", + ERR_NOOPERHOST => "491", + ERR_UMODEUNKNOWNFLAG => "501", + }.to_owned() + } +}*/ + + +/* +impl FromStr for Command { + fn from_str(s: &str) -> Option { + use self::Command::*; + match s { + "PASS" => Some(PASS), + "NICK" => Some(NICK), + "USER" => Some(USER), + "OPER" => Some(OPER), + "MODE" => Some(MODE), + "SERVICE" => Some(SERVICE), + "QUIT" => Some(QUIT), + "SQUIT" => Some(SQUIT), + "JOIN" => Some(JOIN), + "PART" => Some(PART), + "TOPIC" => Some(TOPIC), + "NAMES" => Some(NAMES), + "LIST" => Some(LIST), + "INVITE" => Some(INVITE), + "KICK" => Some(KICK), + "PRIVMSG" => Some(PRIVMSG), + "NOTICE" => Some(NOTICE), + "MOTD" => Some(MOTD), + "LUSERS" => Some(LUSERS), + "VERSION" => Some(VERSION), + "STATS" => Some(STATS), + "LINKS" => Some(LINKS), + "TIME" => Some(TIME), + "CONNECT" => Some(CONNECT), + "TRACE" => Some(TRACE), + "ADMIN" => Some(ADMIN), + "INFO" => Some(INFO), + "SERVLIST" => Some(SERVLIST), + "SQUERY" => Some(SQUERY), + "WHO" => Some(WHO), + "WHOIS" => Some(WHOIS), + "WHOWAS" => Some(WHOWAS), + "KILL" => Some(KILL), + "PING" => Some(PING), + "PONG" => Some(PONG), + "ERROR" => Some(ERROR), + "AWAY" => Some(AWAY), + "REHASH" => Some(REHASH), + "DIE" => Some(DIE), + "RESTART" => Some(RESTART), + "SUMMON" => Some(SUMMON), + "USERS" => Some(USERS), + "WALLOPS" => Some(WALLOPS), + "USERHOST" => Some(USERHOST), + "ISON" => Some(ISON), + _ => None + } + } +}*/ + +/// If you hoped it couldn't get any uglier... I'm sorry, it does. +/// Why a giant match? API. +/// +/// I tried structuring it as a bunch of structs that impl a `Command` trait, +/// but the user would have to use Any and lots of cats. Also, extensibility isn't +/// really a goal; the IRC protocol doesn't seem to evolve very fast. +/// +/// Granted, I *could* have used a phf-map to map to functions to parse this, which +/// - while more readable - shouldn't have resulted in performance gains. +/// +/// Please don't cry. + +impl<'a> Command<'a> { + pub fn from_message(msg: &'a Message) -> Option> { + match &msg.command { + "NOTICE" => msg.content.get(0).and_then(|c| msg.content.get(1).map(|t| + Command::Notice { to: Cow::Borrowed(&t), content: Cow::Borrowed(&c) })), + "PING" => msg.content.get(0).and_then(|s1| msg.content.get(1).map(|s2| + Command::Ping { server1: Some(Cow::Borrowed(&s1)), server2: Some(Cow::Borrowed(&s2)) })), + "451" => Some(Command::ErrNotRegistered), + _ => unimplemented!() + } + } + pub fn to_message(&'a self) -> Message { + match self { + &Command::Ping { ref server1, ref server2 } => { + let mut c = Vec::new(); + if let &Some(ref s) = server1 { c.push(s.clone()) } + if let &Some(ref s) = server2 { c.push(s.clone()) } + Message::new(None, Cow::Owned("PING".to_owned()), c, None, MsgType::Irc) + }, + &Command::Pong { ref server1, ref server2 } => { + let mut c = Vec::new(); + if let &Some(ref s) = server1 { c.push(s.clone()) } + if let &Some(ref s) = server2 { c.push(s.clone()) } + Message::new(None, Cow::Owned("PONG".to_owned()), c, None, MsgType::Irc) + }, + _ => unimplemented!() + } + } + + //pub fn is_reply(&self) -> bool { let i = *self as uint; i >= 200 && i <= 399 } + //pub fn is_error(&self) -> bool { let i = *self as uint; i >= 400 && i <= 599 } } -pub fn join(v: Vec, from: uint) -> String { +pub fn join(v: Vec, from: usize) -> String { let mut msg = if v[from].chars().next().unwrap() == ':' { - v[from][][1..].to_owned() + v[from][1..].to_owned() } else { v[from].clone() }; for m in v.iter().skip(from + 1) { msg.push_str(" "); @@ -809,3 +1172,36 @@ impl ParseResult for PrivMsg { } } }*/ + +#[cfg(test)] +mod test { + use std::borrow::{ Cow, ToOwned }; + use message::{ Message, MsgType }; + + #[test] + fn parse_message() { + let a = ":a.b.c NOTICE AUTH :*** Looking up your hostname..."; + // I'm not even kidding... + let a2 = Message::new( + Some(Cow::Owned("a.b.c".to_owned())), + Cow::Owned("NOTICE".to_owned()), + vec![Cow::Owned("AUTH".to_owned())], + Some(Cow::Owned("*** Looking up your hostname...".to_owned())), + MsgType::Irc + ); + assert_eq!(a.parse(), Some(a2.clone())); + assert_eq!(a2.to_string(), a); + + let b = ":d PRIVMSG You :\u{1}ACTION sends you funny pictures of cats!\u{1}"; + let b2 = Message::new( + Some(Cow::Owned("d".to_owned())), + Cow::Owned("PRIVMSG".to_owned()), + vec![Cow::Owned("You".to_owned())], + Some(Cow::Owned("\u{1}ACTION sends you funny pictures of cats!\u{1}".to_owned())), + MsgType::Ctcp + ); + assert_eq!(b.parse(), Some(b2.clone())); + assert_eq!(b2.to_string(), b); + } + +} -- cgit v1.2.3