//! Oracle-free golden tests for the taxi/flight-master arc's protocol layer (decision 0484 phase //! 1): the four `CMSG_TAXI*` send verbs, the `SMSG_SHOWTAXINODES` map + `TaxiMask` bit law, the //! `SMSG_TAXINODE_STATUS` status/learn packet, `SMSG_ACTIVATETAXIREPLY`'s verdict codes, and the //! empty `SMSG_NEW_TAXI_PATH` ack. Same idioms as `trainer.rs`/`gossip_vendor.rs` — `hx(...)` //! golden CMSG bodies, hand-built SMSG bodies round-tripped through `parse_server`, each SMSG's //! `decode()` bridge exercised too. use benilla_protocol::events::{decode, SessionEvent}; use benilla_protocol::messages::{self, taxi_reply, TaxiMask}; use benilla_protocol::ServerPacket; fn hx(s: &str) -> Vec { (0..s.len()) .step_by(2) .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap()) .collect() } #[test] fn taxi_send_bodies_golden() { // CMSG_TAXINODE_STATUS_QUERY / CMSG_TAXIQUERYAVAILABLENODES (vmangos Packets/Taxi.cpp): both // a single full 8-byte guid — same shape as CMSG_GOSSIP_HELLO / CMSG_TRAINER_LIST. assert_eq!( messages::taxi_node_status_query(0x1234_5678_9abc_def0), hx("f0debc9a78563412"), "CMSG_TAXINODE_STATUS_QUERY body" ); assert_eq!( messages::taxi_query_available_nodes(0x1234_5678_9abc_def0), hx("f0debc9a78563412"), "CMSG_TAXIQUERYAVAILABLENODES body" ); // CMSG_ACTIVATETAXI (vmangos ActivateTaxi::ReadFromWorldPacket): guid, node1, node2 — a // single-hop flight, Stormwind (2) -> Sentinel Hill (4). assert_eq!( messages::activate_taxi(0x1234_5678_9abc_def0, 2, 4), hx(concat!("f0debc9a78563412", "02000000", "04000000")), "CMSG_ACTIVATETAXI body" ); // CMSG_ACTIVATETAXIEXPRESS (vmangos ActivateTaxiExpress::ReadFromWorldPacket): guid, // totalcost, nodeCount, nodeCount x node — a 3-node chain at a combined 110-copper fare. assert_eq!( messages::activate_taxi_express(0x1234_5678_9abc_def0, 110, &[2, 3, 4]), hx(concat!( "f0debc9a78563412", "6e000000", "03000000", "02000000", "03000000", "04000000" )), "CMSG_ACTIVATETAXIEXPRESS body" ); // An empty node list still writes a zero count, not a truncated body. assert_eq!( messages::activate_taxi_express(0x1234_5678_9abc_def0, 0, &[]), hx(concat!("f0debc9a78563412", "00000000", "00000000")), "CMSG_ACTIVATETAXIEXPRESS body, empty node list" ); } #[test] fn taxi_mask_bit_law() { // Bit law (vmangos PlayerTaxi.h IsTaximaskNodeKnown/SetTaximaskNode): 1-based node id, // field = (id-1)/32, bit = (id-1)%32. Node 2 -> field 0 bit 1 (0x2); node 4 -> field 0 bit 3 // (0x8); node 33 -> field 1 bit 0 (0x1) — the first id that crosses into the second word. let mask = TaxiMask([0x0000_000A, 0x0000_0001, 0, 0, 0, 0, 0, 0]); assert!(mask.is_known(2)); assert!(mask.is_known(4)); assert!(mask.is_known(33)); assert!(!mask.is_known(3), "bit not set for node 3"); assert!(!mask.is_known(65), "field 2 is all-zero"); assert!(!mask.is_known(0), "node id 0 is never valid"); } #[test] fn show_taxi_nodes_wire() { // SMSG_SHOWTAXINODES (vmangos SendTaxiMenu, TaxiHandler.cpp:82-96): u32 windowConstant // (always 1), u64 flightmasterGuid (PLAIN, not packed), u32 nearestNode, u32[8] knownMask. // 48 bytes fixed. Mask carries node 2 (Stormwind) and node 33 (crosses into the second word). let mut body = 1u32.to_le_bytes().to_vec(); // window constant body.extend_from_slice(&0xCCu64.to_le_bytes()); // flightmaster guid body.extend_from_slice(&2u32.to_le_bytes()); // nearest node let mask_words = [0x0000_0002u32, 0x0000_0001, 0, 0, 0, 0, 0, 0]; for w in mask_words { body.extend_from_slice(&w.to_le_bytes()); } assert_eq!(body.len(), 4 + 8 + 4 + 8 * 4, "48-byte fixed body"); match messages::parse_server(messages::opcode::SMSG_SHOWTAXINODES, &body).unwrap() { ServerPacket::ShowTaxiNodes { window, flightmaster, nearest_node, known, } => { assert_eq!((window, flightmaster, nearest_node), (1, 0xCC, 2)); assert_eq!(known, TaxiMask(mask_words)); assert!(known.is_known(2)); assert!(known.is_known(33)); assert!(!known.is_known(3)); } other => panic!("show taxi nodes, got {}", other.name()), } // The decode() bridge drops the gate word and carries the rest straight through. let packet = messages::parse_server(messages::opcode::SMSG_SHOWTAXINODES, &body).unwrap(); match decode(packet).pop().unwrap() { SessionEvent::TaxiNodesShown { flightmaster, nearest_node, known_mask, } => { assert_eq!((flightmaster, nearest_node), (0xCC, 2)); assert_eq!(known_mask, TaxiMask(mask_words)); } other => panic!("taxi nodes shown event, got {other:?}"), } // The leading word is the client parser's own conditional gate (0496 §claim-1): a zero gate // ends the body right there — 4 bytes total, and no event out of decode. vmangos never sends // it; the parse is faithful anyway. let gated = 0u32.to_le_bytes().to_vec(); let packet = messages::parse_server(messages::opcode::SMSG_SHOWTAXINODES, &gated).unwrap(); assert!( decode(packet).is_empty(), "a zero-gated SHOWTAXINODES carries no menu and yields no event" ); } #[test] fn taxi_node_status_wire() { // SMSG_TAXINODE_STATUS (vmangos TaxiNodeStatus::AppendBodyTo): u64 guid (PLAIN), u8 known // (a C++ bool — one byte). Exercise both known and unknown. let mut known_body = 0xCCu64.to_le_bytes().to_vec(); known_body.push(1); match messages::parse_server(messages::opcode::SMSG_TAXINODE_STATUS, &known_body).unwrap() { ServerPacket::TaxiNodeStatus { guid, known } => assert_eq!((guid, known), (0xCC, true)), other => panic!("taxi node status, got {}", other.name()), } let packet = messages::parse_server(messages::opcode::SMSG_TAXINODE_STATUS, &known_body).unwrap(); match decode(packet).pop().unwrap() { SessionEvent::TaxiNodeStatus { guid, known } => assert_eq!((guid, known), (0xCC, true)), other => panic!("taxi node status event, got {other:?}"), } let mut unknown_body = 0xDDu64.to_le_bytes().to_vec(); unknown_body.push(0); match messages::parse_server(messages::opcode::SMSG_TAXINODE_STATUS, &unknown_body).unwrap() { ServerPacket::TaxiNodeStatus { guid, known } => assert_eq!((guid, known), (0xDD, false)), other => panic!("taxi node status (unknown), got {}", other.name()), } } #[test] fn activate_taxi_reply_and_new_taxi_path_wire() { // SMSG_ACTIVATETAXIREPLY (vmangos ActivateTaxiReply::AppendBodyTo): one u32 TaxiError code. let body = taxi_reply::NOT_ENOUGH_MONEY.to_le_bytes().to_vec(); match messages::parse_server(messages::opcode::SMSG_ACTIVATETAXIREPLY, &body).unwrap() { ServerPacket::ActivateTaxiReply { code } => { assert_eq!(code, taxi_reply::NOT_ENOUGH_MONEY); } other => panic!("activate taxi reply, got {}", other.name()), } let packet = messages::parse_server(messages::opcode::SMSG_ACTIVATETAXIREPLY, &body).unwrap(); match decode(packet).pop().unwrap() { SessionEvent::ActivateTaxiReply { code } => { assert_eq!(code, taxi_reply::NOT_ENOUGH_MONEY); } other => panic!("activate taxi reply event, got {other:?}"), } // TaxiError values (vmangos Objects/Player.h:404-416) — pinned so a future edit can't drift // them. Codes actually emitted by Player::ActivateTaxiPathTo (this session's grep of // Player.cpp:18008-18252): OK, UNSPECIFIED_SERVER_ERROR, NO_SUCH_PATH, NOT_ENOUGH_MONEY, // TOO_FAR, BUSY, ALREADY_MOUNTED, SHAPESHIFTED. The rest are defined but never sent. // (13-wide, so an array rather than a tuple — Rust's tuple trait impls stop at 12.) assert_eq!( [ taxi_reply::OK, taxi_reply::UNSPECIFIED_SERVER_ERROR, taxi_reply::NO_SUCH_PATH, taxi_reply::NOT_ENOUGH_MONEY, taxi_reply::TOO_FAR, taxi_reply::NO_VENDOR_NEARBY, taxi_reply::NOT_VISITED, taxi_reply::BUSY, taxi_reply::ALREADY_MOUNTED, taxi_reply::SHAPESHIFTED, taxi_reply::PLAYER_MOVING, taxi_reply::SAME_NODE, taxi_reply::NOT_STANDING, ], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] ); // SMSG_NEW_TAXI_PATH — empty body (vmangos NewTaxiPath::AppendBodyTo writes nothing). match messages::parse_server(messages::opcode::SMSG_NEW_TAXI_PATH, &[]).unwrap() { ServerPacket::NewTaxiPath => {} other => panic!("new taxi path, got {}", other.name()), } let packet = messages::parse_server(messages::opcode::SMSG_NEW_TAXI_PATH, &[]).unwrap(); match decode(packet).pop().unwrap() { SessionEvent::NewTaxiPath => {} other => panic!("new taxi path event, got {other:?}"), } }