Vendor dependencies for 0.3.0 release

vendor/x11rb-protocol/tests/enum_tests.rs

@@ -0,0 +1,132 @@
+use x11rb_protocol::protocol::xproto::EventMask;
+
+#[test]
+fn test_conversion() {
+    assert_eq!(0, u32::from(EventMask::NO_EVENT));
+    assert_eq!(1, u32::from(EventMask::KEY_PRESS));
+    assert_eq!(4, u32::from(EventMask::BUTTON_PRESS));
+    assert_eq!(Some(16u32), EventMask::ENTER_WINDOW.into());
+    assert_eq!(EventMask::NO_EVENT, 0u8.into());
+    assert_eq!(EventMask::KEY_PRESS, 1u8.into());
+}
+
+#[test]
+fn test_bit_or() {
+    assert_eq!(
+        EventMask::KEY_PRESS,
+        EventMask::KEY_PRESS | EventMask::NO_EVENT
+    );
+    assert_eq!(EventMask::KEY_PRESS, 1 | EventMask::NO_EVENT);
+    assert_eq!(EventMask::KEY_PRESS, EventMask::NO_EVENT | 1);
+
+    let mut mask = EventMask::KEY_PRESS;
+    mask |= EventMask::BUTTON_PRESS;
+    assert_eq!(5, u32::from(mask));
+
+    let mut mask = EventMask::KEY_PRESS;
+    mask |= 4u32;
+    assert_eq!(5, u32::from(mask));
+
+    let mut mask = 1u32;
+    mask |= EventMask::BUTTON_PRESS;
+    assert_eq!(5, mask);
+}
+
+#[test]
+fn test_bit_and() {
+    assert_eq!(
+        EventMask::NO_EVENT,
+        EventMask::KEY_PRESS & EventMask::NO_EVENT
+    );
+    assert_eq!(
+        EventMask::KEY_PRESS,
+        EventMask::KEY_PRESS & EventMask::KEY_PRESS
+    );
+    assert_eq!(
+        EventMask::KEY_PRESS,
+        EventMask::from(5u32) & EventMask::KEY_PRESS
+    );
+    assert_eq!(EventMask::KEY_PRESS, 5 & EventMask::KEY_PRESS);
+    assert_eq!(EventMask::KEY_PRESS, EventMask::KEY_PRESS & 5);
+
+    let mut mask = EventMask::from(5u32);
+    mask &= EventMask::BUTTON_PRESS;
+    assert_eq!(EventMask::BUTTON_PRESS, mask);
+
+    let mut mask = EventMask::from(5u32);
+    mask &= 4u32;
+    assert_eq!(EventMask::BUTTON_PRESS, mask);
+
+    let mut mask = 7u32;
+    mask &= EventMask::from(21u32);
+    assert_eq!(5, mask);
+}
+
+#[test]
+fn test_contains() {
+    let mask = EventMask::KEY_PRESS;
+    assert!(mask.contains(EventMask::KEY_PRESS));
+    assert!(mask.contains(EventMask::NO_EVENT));
+    assert!(!mask.contains(EventMask::KEY_PRESS | EventMask::BUTTON_PRESS));
+    assert!(!mask.contains(EventMask::BUTTON_PRESS));
+
+    let mask = EventMask::KEY_PRESS | EventMask::BUTTON_PRESS;
+    assert!(mask.contains(EventMask::KEY_PRESS));
+    assert!(mask.contains(EventMask::BUTTON_PRESS));
+    assert!(mask.contains(EventMask::KEY_PRESS | EventMask::BUTTON_PRESS));
+    assert!(!mask.contains(EventMask::ENTER_WINDOW));
+    assert!(!mask.contains(EventMask::ENTER_WINDOW | EventMask::BUTTON_PRESS));
+
+    assert!(mask.contains(1u32));
+    assert!(mask.contains(4u32));
+    assert!(mask.contains(5u32));
+    assert!(!mask.contains(16u32));
+    assert!(!mask.contains(20u32));
+}
+
+#[test]
+fn test_intersects() {
+    let mask = EventMask::KEY_PRESS;
+    assert!(mask.intersects(EventMask::KEY_PRESS));
+    assert!(!mask.intersects(EventMask::NO_EVENT));
+    assert!(mask.intersects(EventMask::KEY_PRESS | EventMask::BUTTON_PRESS));
+    assert!(!mask.intersects(EventMask::BUTTON_PRESS));
+
+    let mask = EventMask::KEY_PRESS | EventMask::BUTTON_PRESS;
+    assert!(mask.intersects(EventMask::KEY_PRESS));
+    assert!(mask.intersects(EventMask::BUTTON_PRESS));
+    assert!(mask.intersects(EventMask::KEY_PRESS | EventMask::BUTTON_PRESS));
+    assert!(!mask.intersects(EventMask::ENTER_WINDOW));
+    assert!(mask.intersects(EventMask::ENTER_WINDOW | EventMask::BUTTON_PRESS));
+
+    assert!(mask.intersects(1u32));
+    assert!(mask.intersects(4u32));
+    assert!(mask.intersects(5u32));
+    assert!(!mask.intersects(16u32));
+    assert!(mask.intersects(20u32));
+}
+
+#[test]
+fn test_remove() {
+    let no_event = EventMask::NO_EVENT;
+    let key_press = EventMask::KEY_PRESS;
+    let button_press = EventMask::BUTTON_PRESS;
+    let exposure = EventMask::EXPOSURE;
+    let key_and_button_press = key_press | button_press;
+
+    assert_eq!(no_event, key_press.remove(key_press));
+    assert_eq!(key_press, key_press.remove(no_event));
+    assert_eq!(key_press, key_press.remove(button_press));
+    assert_eq!(key_press, key_and_button_press.remove(button_press));
+    assert_eq!(key_press, key_and_button_press.remove(button_press));
+    assert_eq!(key_and_button_press, key_and_button_press.remove(exposure));
+
+    assert_eq!(no_event, key_press.remove(1u32));
+    assert_eq!(key_press, key_press.remove(0u32));
+    assert_eq!(key_press, key_press.remove(4u32));
+    assert_eq!(key_press, key_and_button_press.remove(4u32));
+    assert_eq!(
+        key_and_button_press,
+        key_and_button_press.remove(1u32 << 15)
+    );
+}

vendor/x11rb-protocol/tests/parsing_tests.rs

@@ -0,0 +1,170 @@
+#![cfg(feature = "extra-traits")]
+
+use x11rb_protocol::errors::ParseError;
+use x11rb_protocol::protocol::xproto::{Setup, VisualClass};
+use x11rb_protocol::x11_utils::TryParse;
+
+fn get_setup_data() -> Vec<u8> {
+    let mut s = Vec::new();
+
+    let vendor_len: u16 = 2;
+    let num_pixmap_formats: u8 = 1;
+    let roots_len: u8 = 18;
+    let header: u16 = 10;
+    let length: u16 =
+        header + vendor_len + 2 * u16::from(num_pixmap_formats) + u16::from(roots_len);
+
+    s.extend([1, 0]); // Status "success" and padding
+    s.extend(11u16.to_ne_bytes()); // major version
+    s.extend(0u16.to_ne_bytes()); // minor version
+    s.extend(length.to_ne_bytes()); // length
+    s.extend(0x1234_5678u32.to_ne_bytes()); // release number
+    s.extend(0x1000_0000u32.to_ne_bytes()); // resource id base
+    s.extend(0x0000_00ffu32.to_ne_bytes()); // resource id mask
+    s.extend(0u32.to_ne_bytes()); // motion buffer size
+    s.extend(6u16.to_ne_bytes()); // vendor length
+    s.extend(0x100u16.to_ne_bytes()); // maximum request length
+    s.push(1); // roots length
+    s.push(num_pixmap_formats); // pixmap formats length
+    s.push(1); // image byte order: MSB first
+    s.push(1); // bitmap format bit order: MSB first
+    s.push(0); // scanline unit
+    s.push(0); // scanline pad
+    s.push(0); // min keycode
+    s.push(0xff); // max keycode
+    s.extend([0, 0, 0, 0]); // padding
+    assert_eq!(s.len(), usize::from(header) * 4);
+
+    s.extend("Vendor  ".bytes()); // vendor + padding
+    assert_eq!(s.len(), usize::from(header + vendor_len) * 4);
+
+    // Pixmap formats, we said above there is one entry
+    s.push(15); // depth
+    s.push(42); // bits per pixel
+    s.push(21); // scanline pad
+    s.extend([0, 0, 0, 0, 0]); // padding
+    assert_eq!(
+        s.len(),
+        4 * usize::from(header + vendor_len + 2 * u16::from(num_pixmap_formats))
+    );
+
+    // Screens, we said above there is one entry
+    s.extend(1u32.to_ne_bytes()); // root window
+    s.extend(2u32.to_ne_bytes()); // default colormap
+    s.extend(3u32.to_ne_bytes()); // white pixel
+    s.extend(4u32.to_ne_bytes()); // black pixel
+    s.extend(0u32.to_ne_bytes()); // current input masks
+    s.extend(0u16.to_ne_bytes()); // width in pixels
+    s.extend(0u16.to_ne_bytes()); // height in pixels
+    s.extend(0u16.to_ne_bytes()); // width in mm
+    s.extend(0u16.to_ne_bytes()); // height in mm
+    s.extend(0u16.to_ne_bytes()); // min installed maps
+    s.extend(0u16.to_ne_bytes()); // max installed maps
+    s.extend(0u32.to_ne_bytes()); // root visual
+    s.extend([0, 0, 0, 1]); // backing stores, save unders, root depths, allowed depths len
+
+    // one depth entry
+    s.extend([99, 0]); // depth and padding
+    s.extend(1u16.to_ne_bytes()); // width visuals len
+    s.extend([0, 0, 0, 0]); // padding
+
+    // one visualtype entry
+    s.extend(80u32.to_ne_bytes()); // visualid
+    s.extend([2, 4]); // class and bits per rgb value
+    s.extend(81u16.to_ne_bytes()); // colormap entries
+    s.extend(82u32.to_ne_bytes()); // red mask
+    s.extend(83u32.to_ne_bytes()); // green mask
+    s.extend(84u32.to_ne_bytes()); // blue mask
+    s.extend([0, 0, 0, 0]); // padding
+
+    assert_eq!(s.len(), usize::from(length) * 4);
+
+    s
+}
+
+#[test]
+fn parse_setup() -> Result<(), ParseError> {
+    let setup = get_setup_data();
+    let (setup, remaining) = Setup::try_parse(&setup)?;
+
+    assert_eq!(remaining.len(), 0);
+
+    assert_eq!(
+        (1, 11, 0),
+        (
+            setup.status,
+            setup.protocol_major_version,
+            setup.protocol_minor_version
+        )
+    );
+    assert_eq!(0x1234_5678, setup.release_number);
+    assert_eq!((0, 0xff), (setup.min_keycode, setup.max_keycode));
+    assert_eq!(b"Vendor", &setup.vendor[..]);
+
+    assert_eq!(1, setup.pixmap_formats.len());
+    let format = &setup.pixmap_formats[0];
+    assert_eq!(15, format.depth);
+    assert_eq!(42, format.bits_per_pixel);
+    assert_eq!(21, format.scanline_pad);
+
+    assert_eq!(1, setup.roots.len());
+    let root = &setup.roots[0];
+    assert_eq!(
+        (1, 2, 3, 4),
+        (
+            root.root,
+            root.default_colormap,
+            root.white_pixel,
+            root.black_pixel
+        )
+    );
+
+    assert_eq!(1, root.allowed_depths.len());
+    let depth = &root.allowed_depths[0];
+    assert_eq!(99, depth.depth);
+
+    assert_eq!(1, depth.visuals.len());
+    let visual = &depth.visuals[0];
+    assert_eq!(80, visual.visual_id);
+    assert_eq!(VisualClass::STATIC_COLOR, visual.class);
+    assert_eq!(4, visual.bits_per_rgb_value);
+    assert_eq!(81, visual.colormap_entries);
+    assert_eq!(82, visual.red_mask);
+    assert_eq!(83, visual.green_mask);
+    assert_eq!(84, visual.blue_mask);
+
+    Ok(())
+}
+
+#[cfg(feature = "xinput")]
+#[test]
+fn parse_xi_get_property_reply_format_0() {
+    let mut s = vec![
+        1, // response_type
+        0, // pad
+    ];
+    s.extend(0u16.to_ne_bytes()); // sequence
+    s.extend(0u32.to_ne_bytes()); // length
+    s.extend(0u32.to_ne_bytes()); // type
+    s.extend(0u32.to_ne_bytes()); // bytes_after
+    s.extend(0u32.to_ne_bytes()); // num_items
+    s.push(0); // format
+    s.extend([0; 11]); // pad
+
+    use x11rb_protocol::protocol::xinput::{XIGetPropertyItems, XIGetPropertyReply};
+    let empty: &[u8] = &[];
+    assert_eq!(
+        XIGetPropertyReply::try_parse(&s),
+        Ok((
+            XIGetPropertyReply {
+                sequence: 0,
+                length: 0,
+                type_: 0,
+                bytes_after: 0,
+                num_items: 0,
+                items: XIGetPropertyItems::InvalidValue(0),
+            },
+            empty,
+        )),
+    );
+}

vendor/x11rb-protocol/tests/request_parsing_tests.rs

@@ -0,0 +1,284 @@
+#![cfg(feature = "request-parsing")]
+#![cfg(feature = "extra-traits")]
+
+use std::borrow::Cow;
+
+use x11rb_protocol::errors::ParseError;
+use x11rb_protocol::x11_utils::RequestHeader;
+
+macro_rules! add_ne {
+    ($data:expr, $add:expr) => {
+        $data.extend(&$add.to_ne_bytes())
+    };
+}
+
+#[test]
+fn test_bad_request_header_opcode() {
+    use x11rb_protocol::protocol::xproto::GetInputFocusRequest;
+    let header = RequestHeader {
+        major_opcode: 1,
+        minor_opcode: 0,
+        remaining_length: 0,
+    };
+    let body = &[];
+    assert_eq!(
+        GetInputFocusRequest::try_parse_request(header, body),
+        Err(ParseError::InvalidValue)
+    );
+}
+
+#[test]
+fn test_bad_request_header_length() {
+    use x11rb_protocol::protocol::xproto::CreateWindowRequest;
+    let header = RequestHeader {
+        major_opcode: 1,
+        minor_opcode: 0,
+        remaining_length: 42,
+    };
+    let body = &[];
+    assert_eq!(
+        CreateWindowRequest::try_parse_request(header, body),
+        Err(ParseError::InsufficientData)
+    );
+}
+
+#[test]
+fn test_create_window1() {
+    use x11rb_protocol::protocol::xproto::{
+        CreateWindowAux, CreateWindowRequest, Gravity, WindowClass,
+    };
+    let header = RequestHeader {
+        major_opcode: 1,
+        minor_opcode: 0x18,
+        remaining_length: 10,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x05c0_0001u32);
+    add_ne!(body, 0x0000_0513u32);
+    add_ne!(body, 0x047bu16);
+    add_ne!(body, 0x0134u16);
+    add_ne!(body, 0x03f5u16);
+    add_ne!(body, 0x033bu16);
+    add_ne!(body, 0x0000u16);
+    add_ne!(body, 0x0001u16);
+    add_ne!(body, 0x0000_0047u32);
+    add_ne!(body, 0x0000_001au32);
+    add_ne!(body, 0xfff2_f1f0u32);
+    add_ne!(body, 0x0000_0000u32);
+    add_ne!(body, 0x0000_0001u32);
+    let r = CreateWindowRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        CreateWindowRequest {
+            depth: 0x18,
+            wid: 0x05c0_0001,
+            parent: 0x0000_0513,
+            x: 0x047b,
+            y: 0x0134,
+            width: 0x03f5,
+            height: 0x033b,
+            border_width: 0,
+            class: WindowClass::INPUT_OUTPUT,
+            visual: 0x47,
+            value_list: Cow::Owned(CreateWindowAux {
+                background_pixel: Some(0xfff2_f1f0),
+                border_pixel: Some(0),
+                bit_gravity: Some(Gravity::NORTH_WEST),
+                ..Default::default()
+            }),
+        }
+    );
+}
+
+#[test]
+fn test_create_window2() {
+    use x11rb_protocol::protocol::xproto::{
+        CreateWindowAux, CreateWindowRequest, Gravity, WindowClass,
+    };
+    let header = RequestHeader {
+        major_opcode: 1,
+        minor_opcode: 0x18,
+        remaining_length: 11,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x0540_0003u32);
+    add_ne!(body, 0x0000_0513u32);
+    add_ne!(body, 0x0000_0000u32);
+    add_ne!(body, 0x0001u16);
+    add_ne!(body, 0x0001u16);
+    add_ne!(body, 0x0000u16);
+    add_ne!(body, 0x0001u16);
+    add_ne!(body, 0x0000_035au32);
+    add_ne!(body, 0x0000_201au32);
+    add_ne!(body, 0x0000_0000u32);
+    add_ne!(body, 0x0000_0000u32);
+    add_ne!(body, 0x0000_0001u32);
+    add_ne!(body, 0x0540_0002u32);
+    let r = CreateWindowRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        CreateWindowRequest {
+            depth: 0x18,
+            wid: 0x0540_0003,
+            parent: 0x0000_0513,
+            x: 0,
+            y: 0,
+            width: 1,
+            height: 1,
+            border_width: 0,
+            class: WindowClass::INPUT_OUTPUT,
+            visual: 0x35a,
+            value_list: Cow::Owned(CreateWindowAux {
+                background_pixel: Some(0),
+                border_pixel: Some(0),
+                bit_gravity: Some(Gravity::NORTH_WEST),
+                colormap: Some(0x0540_0002),
+                ..Default::default()
+            }),
+        }
+    );
+}
+
+#[test]
+fn test_change_window_attributes() {
+    use x11rb_protocol::protocol::xproto::{
+        ChangeWindowAttributesAux, ChangeWindowAttributesRequest, EventMask,
+    };
+    let header = RequestHeader {
+        major_opcode: 2,
+        minor_opcode: 0,
+        remaining_length: 3,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x0000_0513u32);
+    add_ne!(body, 0x0000_0800u32);
+    add_ne!(body, 0x0040_0000u32);
+    let r = ChangeWindowAttributesRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        ChangeWindowAttributesRequest {
+            window: 0x0513,
+            value_list: Cow::Owned(ChangeWindowAttributesAux {
+                event_mask: Some(EventMask::PROPERTY_CHANGE),
+                ..Default::default()
+            }),
+        }
+    );
+}
+
+#[test]
+fn test_get_window_attributes() {
+    use x11rb_protocol::protocol::xproto::GetWindowAttributesRequest;
+    let header = RequestHeader {
+        major_opcode: 3,
+        minor_opcode: 0,
+        remaining_length: 1,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x00e0_0002u32);
+    let r = GetWindowAttributesRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        GetWindowAttributesRequest {
+            window: 0x00e0_0002
+        }
+    );
+}
+
+#[test]
+fn test_get_input_focus() {
+    use x11rb_protocol::protocol::xproto::GetInputFocusRequest;
+    let header = RequestHeader {
+        major_opcode: 43,
+        minor_opcode: 0,
+        remaining_length: 0,
+    };
+    let body = &[];
+    let r = GetInputFocusRequest::try_parse_request(header, body).unwrap();
+    assert_eq!(r, GetInputFocusRequest,);
+}
+
+#[test]
+fn test_query_text_extents() {
+    use x11rb_protocol::protocol::xproto::{Char2b, QueryTextExtentsRequest};
+    let header = RequestHeader {
+        major_opcode: 48,
+        minor_opcode: 0,
+        remaining_length: 2,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x1234_5678u32);
+    body.extend([0xbc, 0x9a, 0xf0, 0xde]);
+    let r = QueryTextExtentsRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        QueryTextExtentsRequest {
+            font: 0x1234_5678,
+            string: Cow::Owned(vec![
+                Char2b {
+                    byte1: 0xbc,
+                    byte2: 0x9a,
+                },
+                Char2b {
+                    byte1: 0xf0,
+                    byte2: 0xde,
+                },
+            ]),
+        }
+    );
+}
+
+#[test]
+fn test_query_text_extents_odd_length() {
+    use x11rb_protocol::protocol::xproto::{Char2b, QueryTextExtentsRequest};
+    let header = RequestHeader {
+        major_opcode: 48,
+        minor_opcode: 1,
+        remaining_length: 2,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x1234_5678u32);
+    body.extend([0xbc, 0x9a, 0xf0, 0xde]);
+    let r = QueryTextExtentsRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        QueryTextExtentsRequest {
+            font: 0x1234_5678,
+            string: Cow::Owned(vec![Char2b {
+                byte1: 0xbc,
+                byte2: 0x9a,
+            },]),
+        }
+    );
+}
+
+#[cfg(feature = "randr")]
+#[test]
+fn test_randr_get_output_property() {
+    use x11rb_protocol::protocol::randr::GetOutputPropertyRequest;
+    let header = RequestHeader {
+        major_opcode: 140,
+        minor_opcode: 15,
+        remaining_length: 6,
+    };
+    let mut body = vec![];
+    add_ne!(body, 0x0000_008au32);
+    add_ne!(body, 0x0000_0045u32);
+    add_ne!(body, 0x0000_0000u32);
+    add_ne!(body, 0x0000_0000u32);
+    add_ne!(body, 0x0000_0080u32);
+    add_ne!(body, 0x0000_0000u32);
+    let r = GetOutputPropertyRequest::try_parse_request(header, &body).unwrap();
+    assert_eq!(
+        r,
+        GetOutputPropertyRequest {
+            output: 0x8a,
+            property: 0x45,
+            type_: 0,
+            long_offset: 0,
+            long_length: 128,
+            delete: false,
+            pending: false,
+        },
+    );
+}