From: Philippe Antoine Date: Thu, 4 Jan 2024 11:48:12 +0000 (+0100) Subject: rust: fix assertions_on_constants for assert!(false) X-Git-Tag: suricata-8.0.0-beta1~1844 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=a8199bf2ca16e8394b6bf5c41ba1bafe88f6ff53;p=thirdparty%2Fsuricata.git rust: fix assertions_on_constants for assert!(false) using panic! instead with a string message --- diff --git a/rust/src/dcerpc/dcerpc_udp.rs b/rust/src/dcerpc/dcerpc_udp.rs index 83707bddcb..d34c3e480b 100644 --- a/rust/src/dcerpc/dcerpc_udp.rs +++ b/rust/src/dcerpc/dcerpc_udp.rs @@ -410,12 +410,7 @@ mod tests { 0x1c, 0x7d, 0xcf, 0x11, ]; - match parser::parse_dcerpc_udp_header(request) { - Ok((_rem, _header)) => { - { assert!(false); } - } - _ => {} - } + assert!(parser::parse_dcerpc_udp_header(request).is_err()); } #[test] @@ -428,13 +423,9 @@ mod tests { 0x79, 0xbe, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x0a, 0x00, ]; - match parser::parse_dcerpc_udp_header(request) { - Ok((rem, header)) => { - assert_eq!(4, header.rpc_vers); - assert_eq!(80, request.len() - rem.len()); - } - _ => { assert!(false); } - } + let (rem, header) = parser::parse_dcerpc_udp_header(request).unwrap(); + assert_eq!(4, header.rpc_vers); + assert_eq!(80, request.len() - rem.len()); } #[test] @@ -447,14 +438,10 @@ mod tests { 0x79, 0xbe, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x0a, 0x00, ]; - match parser::parse_dcerpc_udp_header(request) { - Ok((rem, header)) => { - assert_eq!(4, header.rpc_vers); - assert_eq!(80, request.len() - rem.len()); - assert_eq!(0, rem.len()); - } - _ => { assert!(false); } - } + let (rem, header) = parser::parse_dcerpc_udp_header(request).unwrap(); + assert_eq!(4, header.rpc_vers); + assert_eq!(80, request.len() - rem.len()); + assert_eq!(0, rem.len()); } #[test] diff --git a/rust/src/detect/byte_math.rs b/rust/src/detect/byte_math.rs index 80bd3d5ee1..0586a92e5d 100644 --- a/rust/src/detect/byte_math.rs +++ b/rust/src/detect/byte_math.rs @@ -517,14 +517,8 @@ mod tests { ..Default::default() }; - match parse_bytemath(args) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath(args).unwrap(); + assert_eq!(val, bmd); } #[test] @@ -623,52 +617,26 @@ mod tests { ..Default::default() }; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string dec", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); bmd.flags = DETECT_BYTEMATH_FLAG_RVALUE_VAR; bmd.base = BASE_DEFAULT; - match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); bmd.flags = DETECT_BYTEMATH_FLAG_RVALUE_VAR | DETECT_BYTEMATH_FLAG_STRING; bmd.base = ByteMathBase::BaseHex; - match parse_bytemath( - "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string hex", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string hex").unwrap(); + assert_eq!(val, bmd); bmd.base = ByteMathBase::BaseOct; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string oct", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); } #[test] @@ -774,40 +742,25 @@ mod tests { }; bmd.bitmask_val = 0x12345678; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, bitmask 0x12345678", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); + bmd.bitmask_val = 0xffff1234; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, bitmask ffff1234", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); + bmd.bitmask_val = 0xffff1234; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, bitmask 0Xffff1234", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); + } #[test] fn test_parser_endian_valid() { @@ -824,49 +777,29 @@ mod tests { ..Default::default() }; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, endian big", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); + bmd.endian = ByteMathEndian::LittleEndian; - match parse_bytemath( + let (_, val) = parse_bytemath( "bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, endian little", - ) { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + ).unwrap(); + assert_eq!(val, bmd); + bmd.endian = ByteMathEndian::EndianDCE; - match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, dce") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, dce").unwrap(); + assert_eq!(val, bmd); + bmd.endian = DETECT_BYTEMATH_ENDIAN_DEFAULT; bmd.flags = DETECT_BYTEMATH_FLAG_RVALUE_VAR; - match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + } #[test] @@ -920,61 +853,31 @@ mod tests { ..Default::default() }; - match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.oper = ByteMathOperator::Subtraction; - match parse_bytemath("bytes 4, offset 3933, oper -, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper -, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.oper = ByteMathOperator::Multiplication; - match parse_bytemath("bytes 4, offset 3933, oper *, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper *, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.oper = ByteMathOperator::Division; - match parse_bytemath("bytes 4, offset 3933, oper /, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper /, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.oper = ByteMathOperator::RightShift; - match parse_bytemath("bytes 4, offset 3933, oper >>, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper >>, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.oper = ByteMathOperator::LeftShift; - match parse_bytemath("bytes 4, offset 3933, oper <<, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 3933, oper <<, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + } #[test] @@ -1013,33 +916,18 @@ mod tests { ..Default::default() }; - match parse_bytemath("bytes 4, offset 47303, oper *, rvalue 4294967295 , result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 47303, oper *, rvalue 4294967295 , result foo").unwrap(); + assert_eq!(val, bmd); + bmd.rvalue = 1; - match parse_bytemath("bytes 4, offset 47303, oper *, rvalue 1, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 47303, oper *, rvalue 1, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.rvalue = 0; - match parse_bytemath("bytes 4, offset 47303, oper *, rvalue 0, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 47303, oper *, rvalue 0, result foo").unwrap(); + assert_eq!(val, bmd); + } #[test] @@ -1064,24 +952,14 @@ mod tests { ..Default::default() }; - match parse_bytemath("bytes 4, offset -65535, oper *, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset -65535, oper *, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + bmd.offset = 65535; - match parse_bytemath("bytes 4, offset 65535, oper *, rvalue myrvalue, result foo") { - Ok((_, val)) => { - assert_eq!(val, bmd); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = parse_bytemath("bytes 4, offset 65535, oper *, rvalue myrvalue, result foo").unwrap(); + assert_eq!(val, bmd); + } #[test] diff --git a/rust/src/detect/uint.rs b/rust/src/detect/uint.rs index 3d6a5baab0..8c758e3a5d 100644 --- a/rust/src/detect/uint.rs +++ b/rust/src/detect/uint.rs @@ -409,27 +409,12 @@ mod tests { #[test] fn test_parse_uint_unit() { - match detect_parse_uint::(" 2kb") { - Ok((_, val)) => { - assert_eq!(val.arg1, 2048); - } - Err(_) => { - assert!(false); - } - } - match detect_parse_uint::("2kb") { - Ok((_, _val)) => { - assert!(false); - } - Err(_) => {} - } - match detect_parse_uint::("3MB") { - Ok((_, val)) => { - assert_eq!(val.arg1, 3 * 1024 * 1024); - } - Err(_) => { - assert!(false); - } - } + let (_, val) = detect_parse_uint::(" 2kb").unwrap(); + assert_eq!(val.arg1, 2048); + + assert!(detect_parse_uint::("2kb").is_err()); + + let (_, val) = detect_parse_uint::("3MB").unwrap(); + assert_eq!(val.arg1, 3 * 1024 * 1024); } } diff --git a/rust/src/dhcp/parser.rs b/rust/src/dhcp/parser.rs index 48acccff2c..698462f301 100644 --- a/rust/src/dhcp/parser.rs +++ b/rust/src/dhcp/parser.rs @@ -242,42 +242,36 @@ mod tests { let pcap = include_bytes!("discover.pcap"); let payload = &pcap[24 + 16 + 42..]; - match dhcp_parse(payload) { - Ok((_rem, message)) => { - let header = message.header; - assert_eq!(header.opcode, BOOTP_REQUEST); - assert_eq!(header.htype, 1); - assert_eq!(header.hlen, 6); - assert_eq!(header.hops, 0); - assert_eq!(header.txid, 0x00003d1d); - assert_eq!(header.seconds, 0); - assert_eq!(header.flags, 0); - assert_eq!(header.clientip, &[0, 0, 0, 0]); - assert_eq!(header.yourip, &[0, 0, 0, 0]); - assert_eq!(header.serverip, &[0, 0, 0, 0]); - assert_eq!(header.giaddr, &[0, 0, 0, 0]); - assert_eq!( - &header.clienthw[..(header.hlen as usize)], - &[0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42] - ); - assert!(header.servername.iter().all(|&x| x == 0)); - assert!(header.bootfilename.iter().all(|&x| x == 0)); - assert_eq!(header.magic, &[0x63, 0x82, 0x53, 0x63]); + let (_rem, message) = dhcp_parse(payload).unwrap(); + let header = message.header; + assert_eq!(header.opcode, BOOTP_REQUEST); + assert_eq!(header.htype, 1); + assert_eq!(header.hlen, 6); + assert_eq!(header.hops, 0); + assert_eq!(header.txid, 0x00003d1d); + assert_eq!(header.seconds, 0); + assert_eq!(header.flags, 0); + assert_eq!(header.clientip, &[0, 0, 0, 0]); + assert_eq!(header.yourip, &[0, 0, 0, 0]); + assert_eq!(header.serverip, &[0, 0, 0, 0]); + assert_eq!(header.giaddr, &[0, 0, 0, 0]); + assert_eq!( + &header.clienthw[..(header.hlen as usize)], + &[0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42] + ); + assert!(header.servername.iter().all(|&x| x == 0)); + assert!(header.bootfilename.iter().all(|&x| x == 0)); + assert_eq!(header.magic, &[0x63, 0x82, 0x53, 0x63]); - assert!(!message.malformed_options); - assert!(!message.truncated_options); + assert!(!message.malformed_options); + assert!(!message.truncated_options); - assert_eq!(message.options.len(), 5); - assert_eq!(message.options[0].code, DHCP_OPT_TYPE); - assert_eq!(message.options[1].code, DHCP_OPT_CLIENT_ID); - assert_eq!(message.options[2].code, DHCP_OPT_REQUESTED_IP); - assert_eq!(message.options[3].code, DHCP_OPT_PARAMETER_LIST); - assert_eq!(message.options[4].code, DHCP_OPT_END); - } - _ => { - assert!(false); - } - } + assert_eq!(message.options.len(), 5); + assert_eq!(message.options[0].code, DHCP_OPT_TYPE); + assert_eq!(message.options[1].code, DHCP_OPT_CLIENT_ID); + assert_eq!(message.options[2].code, DHCP_OPT_REQUESTED_IP); + assert_eq!(message.options[3].code, DHCP_OPT_PARAMETER_LIST); + assert_eq!(message.options[4].code, DHCP_OPT_END); } #[test] diff --git a/rust/src/dns/parser.rs b/rust/src/dns/parser.rs index f7f9fd0d6e..3d9938abf8 100644 --- a/rust/src/dns/parser.rs +++ b/rust/src/dns/parser.rs @@ -477,35 +477,29 @@ mod tests { let (body, header) = dns_parse_header(pkt).unwrap(); let res = dns_parse_body(body, pkt, header); - match res { - Ok((rem, request)) => { - // For now we have some remainder data as there is an - // additional record type we don't parse yet. - assert!(!rem.is_empty()); - - assert_eq!( - request.header, - DNSHeader { - tx_id: 0x8d32, - flags: 0x0120, - questions: 1, - answer_rr: 0, - authority_rr: 0, - additional_rr: 1, - } - ); - - assert_eq!(request.queries.len(), 1); + let (rem, request) = res.unwrap(); + // For now we have some remainder data as there is an + // additional record type we don't parse yet. + assert!(!rem.is_empty()); - let query = &request.queries[0]; - assert_eq!(query.name, "www.suricata-ids.org".as_bytes().to_vec()); - assert_eq!(query.rrtype, 1); - assert_eq!(query.rrclass, 1); - } - _ => { - assert!(false); + assert_eq!( + request.header, + DNSHeader { + tx_id: 0x8d32, + flags: 0x0120, + questions: 1, + answer_rr: 0, + authority_rr: 0, + additional_rr: 1, } - } + ); + + assert_eq!(request.queries.len(), 1); + + let query = &request.queries[0]; + assert_eq!(query.name, "www.suricata-ids.org".as_bytes().to_vec()); + assert_eq!(query.rrtype, 1); + assert_eq!(query.rrclass, 1); } /// Parse a DNS response. @@ -534,64 +528,57 @@ mod tests { 0x00, 0x04, 0xc0, 0x00, 0x4e, 0x19, /* ....N. */ ]; - let res = dns_parse_response(pkt); - match res { - Ok((rem, response)) => { - // The response should be full parsed. - assert_eq!(rem.len(), 0); - - assert_eq!( - response.header, - DNSHeader { - tx_id: 0x8d32, - flags: 0x81a0, - questions: 1, - answer_rr: 3, - authority_rr: 0, - additional_rr: 0, - } - ); - - assert_eq!(response.answers.len(), 3); - - let answer1 = &response.answers[0]; - assert_eq!(answer1.name, "www.suricata-ids.org".as_bytes().to_vec()); - assert_eq!(answer1.rrtype, 5); - assert_eq!(answer1.rrclass, 1); - assert_eq!(answer1.ttl, 3544); - assert_eq!( - answer1.data, - DNSRData::CNAME("suricata-ids.org".as_bytes().to_vec()) - ); - - let answer2 = &response.answers[1]; - assert_eq!( - answer2, - &DNSAnswerEntry { - name: "suricata-ids.org".as_bytes().to_vec(), - rrtype: 1, - rrclass: 1, - ttl: 244, - data: DNSRData::A([192, 0, 78, 24].to_vec()), - } - ); - - let answer3 = &response.answers[2]; - assert_eq!( - answer3, - &DNSAnswerEntry { - name: "suricata-ids.org".as_bytes().to_vec(), - rrtype: 1, - rrclass: 1, - ttl: 244, - data: DNSRData::A([192, 0, 78, 25].to_vec()), - } - ) + let (rem, response) = dns_parse_response(pkt).unwrap(); + // The response should be full parsed. + assert_eq!(rem.len(), 0); + + assert_eq!( + response.header, + DNSHeader { + tx_id: 0x8d32, + flags: 0x81a0, + questions: 1, + answer_rr: 3, + authority_rr: 0, + additional_rr: 0, + } + ); + + assert_eq!(response.answers.len(), 3); + + let answer1 = &response.answers[0]; + assert_eq!(answer1.name, "www.suricata-ids.org".as_bytes().to_vec()); + assert_eq!(answer1.rrtype, 5); + assert_eq!(answer1.rrclass, 1); + assert_eq!(answer1.ttl, 3544); + assert_eq!( + answer1.data, + DNSRData::CNAME("suricata-ids.org".as_bytes().to_vec()) + ); + + let answer2 = &response.answers[1]; + assert_eq!( + answer2, + &DNSAnswerEntry { + name: "suricata-ids.org".as_bytes().to_vec(), + rrtype: 1, + rrclass: 1, + ttl: 244, + data: DNSRData::A([192, 0, 78, 24].to_vec()), } - _ => { - assert!(false); + ); + + let answer3 = &response.answers[2]; + assert_eq!( + answer3, + &DNSAnswerEntry { + name: "suricata-ids.org".as_bytes().to_vec(), + rrtype: 1, + rrclass: 1, + ttl: 244, + data: DNSRData::A([192, 0, 78, 25].to_vec()), } - } + ) } #[test] @@ -617,49 +604,42 @@ mod tests { 0x00, 0x00, 0x00, 0x00, /* .... */ ]; - let res = dns_parse_response(pkt); - match res { - Ok((rem, response)) => { - // For now we have some remainder data as there is an - // additional record type we don't parse yet. - assert!(!rem.is_empty()); - - assert_eq!( - response.header, - DNSHeader { - tx_id: 0x8295, - flags: 0x8183, - questions: 1, - answer_rr: 0, - authority_rr: 1, - additional_rr: 1, - } - ); - - assert_eq!(response.authorities.len(), 1); - - let authority = &response.authorities[0]; - assert_eq!(authority.name, "oisf.net".as_bytes().to_vec()); - assert_eq!(authority.rrtype, 6); - assert_eq!(authority.rrclass, 1); - assert_eq!(authority.ttl, 899); - assert_eq!( - authority.data, - DNSRData::SOA(DNSRDataSOA { - mname: "ns-110.awsdns-13.com".as_bytes().to_vec(), - rname: "awsdns-hostmaster.amazon.com".as_bytes().to_vec(), - serial: 1, - refresh: 7200, - retry: 900, - expire: 1209600, - minimum: 86400, - }) - ); - } - _ => { - assert!(false); + let (rem, response) = dns_parse_response(pkt).unwrap(); + // For now we have some remainder data as there is an + // additional record type we don't parse yet. + assert!(!rem.is_empty()); + + assert_eq!( + response.header, + DNSHeader { + tx_id: 0x8295, + flags: 0x8183, + questions: 1, + answer_rr: 0, + authority_rr: 1, + additional_rr: 1, } - } + ); + + assert_eq!(response.authorities.len(), 1); + + let authority = &response.authorities[0]; + assert_eq!(authority.name, "oisf.net".as_bytes().to_vec()); + assert_eq!(authority.rrtype, 6); + assert_eq!(authority.rrclass, 1); + assert_eq!(authority.ttl, 899); + assert_eq!( + authority.data, + DNSRData::SOA(DNSRDataSOA { + mname: "ns-110.awsdns-13.com".as_bytes().to_vec(), + rname: "awsdns-hostmaster.amazon.com".as_bytes().to_vec(), + serial: 1, + refresh: 7200, + retry: 900, + expire: 1209600, + minimum: 86400, + }) + ); } #[test] @@ -678,49 +658,42 @@ mod tests { 0x44, 0x03, 0xc5, 0xe9, 0x01, /* D.... */ ]; - let res = dns_parse_response(pkt); - match res { - Ok((rem, response)) => { - // The response should be fully parsed. - assert_eq!(rem.len(), 0); - - assert_eq!( - response.header, - DNSHeader { - tx_id: 0x12b0, - flags: 0x8400, - questions: 1, - answer_rr: 1, - authority_rr: 0, - additional_rr: 0, - } - ); - - assert_eq!(response.queries.len(), 1); - let query = &response.queries[0]; - assert_eq!(query.name, "vaaaakardli.pirate.sea".as_bytes().to_vec()); - assert_eq!(query.rrtype, DNS_RECORD_TYPE_NULL); - assert_eq!(query.rrclass, 1); - - assert_eq!(response.answers.len(), 1); - - let answer = &response.answers[0]; - assert_eq!(answer.name, "vaaaakardli.pirate.sea".as_bytes().to_vec()); - assert_eq!(answer.rrtype, DNS_RECORD_TYPE_NULL); - assert_eq!(answer.rrclass, 1); - assert_eq!(answer.ttl, 0); - assert_eq!( - answer.data, - DNSRData::NULL(vec![ - 0x56, 0x41, 0x43, 0x4b, /* VACK */ - 0x44, 0x03, 0xc5, 0xe9, 0x01, /* D.... */ - ]) - ); - } - _ => { - assert!(false); + let (rem, response) = dns_parse_response(pkt).unwrap(); + // The response should be fully parsed. + assert_eq!(rem.len(), 0); + + assert_eq!( + response.header, + DNSHeader { + tx_id: 0x12b0, + flags: 0x8400, + questions: 1, + answer_rr: 1, + authority_rr: 0, + additional_rr: 0, } - } + ); + + assert_eq!(response.queries.len(), 1); + let query = &response.queries[0]; + assert_eq!(query.name, "vaaaakardli.pirate.sea".as_bytes().to_vec()); + assert_eq!(query.rrtype, DNS_RECORD_TYPE_NULL); + assert_eq!(query.rrclass, 1); + + assert_eq!(response.answers.len(), 1); + + let answer = &response.answers[0]; + assert_eq!(answer.name, "vaaaakardli.pirate.sea".as_bytes().to_vec()); + assert_eq!(answer.rrtype, DNS_RECORD_TYPE_NULL); + assert_eq!(answer.rrclass, 1); + assert_eq!(answer.ttl, 0); + assert_eq!( + answer.data, + DNSRData::NULL(vec![ + 0x56, 0x41, 0x43, 0x4b, /* VACK */ + 0x44, 0x03, 0xc5, 0xe9, 0x01, /* D.... */ + ]) + ); } #[test] @@ -734,26 +707,16 @@ mod tests { 0x9a, 0xbc, 0xde, 0xf6, 0x78, 0x90, ]; - let res = dns_parse_rdata_sshfp(data); - match res { - Ok((rem, rdata)) => { - // The data should be fully parsed. - assert_eq!(rem.len(), 0); - - match rdata { - DNSRData::SSHFP(sshfp) => { - assert_eq!(sshfp.algo, 2); - assert_eq!(sshfp.fp_type, 1); - assert_eq!(sshfp.fingerprint, &data[2..]); - } - _ => { - assert!(false); - } - } - } - _ => { - assert!(false); - } + let (rem, rdata) = dns_parse_rdata_sshfp(data).unwrap(); + // The data should be fully parsed. + assert_eq!(rem.len(), 0); + + if let DNSRData::SSHFP(sshfp) = rdata { + assert_eq!(sshfp.algo, 2); + assert_eq!(sshfp.fp_type, 1); + assert_eq!(sshfp.fingerprint, &data[2..]); + } else { + panic!("Expected DNSRData::SSHFP"); } } @@ -790,48 +753,35 @@ mod tests { 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, ]; - let res = dns_parse_response(pkt); - match res { - Ok((rem, response)) => { - // The data should be fully parsed. - assert_eq!(rem.len(), 0); - - assert_eq!(response.answers.len(), 2); - - let answer1 = &response.answers[0]; - match &answer1.data { - DNSRData::SRV(srv) => { - assert_eq!(srv.priority, 20); - assert_eq!(srv.weight, 1); - assert_eq!(srv.port, 5060); - assert_eq!( - srv.target, - "sip-anycast-2.voice.google.com".as_bytes().to_vec() - ); - } - _ => { - assert!(false); - } - } - let answer2 = &response.answers[1]; - match &answer2.data { - DNSRData::SRV(srv) => { - assert_eq!(srv.priority, 10); - assert_eq!(srv.weight, 1); - assert_eq!(srv.port, 5060); - assert_eq!( - srv.target, - "sip-anycast-1.voice.google.com".as_bytes().to_vec() - ); - } - _ => { - assert!(false); - } - } - } - _ => { - assert!(false); - } + let (rem, response) = dns_parse_response(pkt).unwrap(); + // The data should be fully parsed. + assert_eq!(rem.len(), 0); + + assert_eq!(response.answers.len(), 2); + + let answer1 = &response.answers[0]; + if let DNSRData::SRV(srv) = &answer1.data { + assert_eq!(srv.priority, 20); + assert_eq!(srv.weight, 1); + assert_eq!(srv.port, 5060); + assert_eq!( + srv.target, + "sip-anycast-2.voice.google.com".as_bytes().to_vec() + ); + } else { + panic!("Expected DNSRData::SRV"); + } + let answer2 = &response.answers[1]; + if let DNSRData::SRV(srv) = &answer2.data { + assert_eq!(srv.priority, 10); + assert_eq!(srv.weight, 1); + assert_eq!(srv.port, 5060); + assert_eq!( + srv.target, + "sip-anycast-1.voice.google.com".as_bytes().to_vec() + ); + } else { + panic!("Expected DNSRData::SRV"); } } } diff --git a/rust/src/sip/parser.rs b/rust/src/sip/parser.rs index a34bc2615e..cd98c252eb 100644 --- a/rust/src/sip/parser.rs +++ b/rust/src/sip/parser.rs @@ -275,17 +275,11 @@ mod tests { \r\n" .as_bytes(); - match sip_parse_request(buf) { - Ok((_, req)) => { - assert_eq!(req.method, "REGISTER"); - assert_eq!(req.path, "sip:sip.cybercity.dk"); - assert_eq!(req.version, "SIP/2.0"); - assert_eq!(req.headers["Content-Length"], "0"); - } - _ => { - assert!(false); - } - } + let (_, req) = sip_parse_request(buf).unwrap(); + assert_eq!(req.method, "REGISTER"); + assert_eq!(req.path, "sip:sip.cybercity.dk"); + assert_eq!(req.version, "SIP/2.0"); + assert_eq!(req.headers["Content-Length"], "0"); } #[test] @@ -311,15 +305,9 @@ mod tests { \r\n" .as_bytes(); - match sip_parse_response(buf) { - Ok((_, resp)) => { - assert_eq!(resp.version, "SIP/2.0"); - assert_eq!(resp.code, "401"); - assert_eq!(resp.reason, "Unauthorized"); - } - _ => { - assert!(false); - } - } + let (_, resp) = sip_parse_response(buf).unwrap(); + assert_eq!(resp.version, "SIP/2.0"); + assert_eq!(resp.code, "401"); + assert_eq!(resp.reason, "Unauthorized"); } }