pub fn new(long: bool, name: String) -> Self {

        Self { long, name }

    }

    pub fn to_bytes(&self) -> Vec<u8> {

        let mut result = Vec::new();

        if self.long {

            result.extend(b"/W ");

        }

        result.extend(self.name.as_bytes());

        result.extend(b"\r\n");

        result

    }

    pub fn from_bytes(bytes: &[u8]) -> Self {

        let (long, name) = if &bytes[..3] == b"/W " {

            (true, &bytes[3..])

            (false, bytes)

        let name = match name.strip_suffix(b"\r\n") {

            Some(new_name) => new_name,

        Self::new(long, String::from_utf8_lossy(name).to_string())

    }

    pub fn new(content: String) -> Self {

        Self(content)

    }

    pub fn from_bytes(bytes: &[u8]) -> Self {

        if bytes.is_empty() {

        }

        fn normalize(c: u8) -> u8 {

            if c == (b'\r' | 0x80) || c == (b'\n' | 0x80) {

                c

        }

        let normalized: Vec<u8> = bytes

            .iter()

            .copied()

            .map(normalize)

            .chain(std::iter::once(normalize(*bytes.last().unwrap())))

            .map_windows(|[a, b]| {

                if *a == b'\r' && *b == b'\n' {

                    None

                    Some(*a)

            })

            .flatten()

            .collect();

        let result = String::from_utf8_lossy(&normalized).to_string();

        Self(result)

    }

    pub fn to_bytes(&self) -> Vec<u8> {

        let mut out = Vec::with_capacity(self.0.len() + 2);

        for &b in self.0.as_bytes() {

            if b == b'\n' {

                out.extend_from_slice(b"\r\n");

            } else {

                out.push(b);

            }

        if !self.0.ends_with('\n') {

        }

        out

    }

    fn test_finger_serialization_roundrip() {

        let request = FingerRequest::new(true, "alice".to_string());

        let bytes = request.to_bytes();

        let deserialized = FingerRequest::from_bytes(&bytes);

        assert_eq!(request, deserialized);

        let request2 = FingerRequest::new(false, "bob".to_string());

        let bytes2 = request2.to_bytes();

        let deserialized2 = FingerRequest::from_bytes(&bytes2);

        assert_eq!(request2, deserialized2);

        let response = FingerResponse::new("Hello, World!\nThis is a test.\n".to_string());

        let response_bytes = response.to_bytes();

        let deserialized_response = FingerResponse::from_bytes(&response_bytes);

        assert_eq!(response, deserialized_response);

        let response2 = FingerResponse::new("Single line response\n".to_string());

        let response_bytes2 = response2.to_bytes();

        let deserialized_response2 = FingerResponse::from_bytes(&response_bytes2);

        assert_eq!(response2, deserialized_response2);

    }