summaryrefslogtreecommitdiffstats
path: root/gfx/wr/peek-poke/tests
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/wr/peek-poke/tests')
-rw-r--r--gfx/wr/peek-poke/tests/max_size.rs117
-rw-r--r--gfx/wr/peek-poke/tests/round_trip.rs275
2 files changed, 392 insertions, 0 deletions
diff --git a/gfx/wr/peek-poke/tests/max_size.rs b/gfx/wr/peek-poke/tests/max_size.rs
new file mode 100644
index 0000000000..67cd1ca4a6
--- /dev/null
+++ b/gfx/wr/peek-poke/tests/max_size.rs
@@ -0,0 +1,117 @@
+// Copyright 2019 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(dead_code)]
+
+use peek_poke::{PeekPoke, Poke};
+use std::{marker::PhantomData, mem::size_of};
+
+#[test]
+fn test_numbers() {
+ assert_eq!(u8::max_size(), size_of::<u8>());
+ assert_eq!(u16::max_size(), size_of::<u16>());
+ assert_eq!(u32::max_size(), size_of::<u32>());
+ assert_eq!(u64::max_size(), size_of::<u64>());
+ assert_eq!(usize::max_size(), size_of::<usize>());
+ assert_eq!(i8::max_size(), size_of::<i8>());
+ assert_eq!(i16::max_size(), size_of::<i16>());
+ assert_eq!(i32::max_size(), size_of::<i32>());
+ assert_eq!(i64::max_size(), size_of::<i64>());
+ assert_eq!(isize::max_size(), size_of::<isize>());
+ // floating
+ assert_eq!(f32::max_size(), size_of::<f32>());
+ assert_eq!(f64::max_size(), size_of::<f64>());
+}
+
+#[test]
+fn test_bool() {
+ assert_eq!(bool::max_size(), size_of::<u8>());
+}
+
+#[test]
+fn test_option() {
+ assert_eq!(
+ Option::<usize>::max_size(),
+ <u8>::max_size() + <usize>::max_size()
+ );
+}
+
+#[test]
+fn test_fixed_size_array() {
+ assert_eq!(<[u32; 32]>::max_size(), 32 * size_of::<u32>());
+ assert_eq!(<[u64; 8]>::max_size(), 8 * size_of::<u64>());
+ assert_eq!(<[u8; 19]>::max_size(), 19 * size_of::<u8>());
+}
+
+#[test]
+fn test_tuple() {
+ assert_eq!(<(isize, )>::max_size(), size_of::<isize>());
+ assert_eq!(<(isize, isize, isize)>::max_size(), 3 * size_of::<isize>());
+ assert_eq!(<(isize, ())>::max_size(), size_of::<isize>());
+}
+
+#[test]
+fn test_basic_struct() {
+ #[derive(Debug, PeekPoke)]
+ struct Bar {
+ a: u32,
+ b: u32,
+ c: u32,
+ }
+
+ assert_eq!(<Bar>::max_size(), 3 * <u32>::max_size());
+}
+
+#[test]
+fn test_enum() {
+ #[derive(Clone, Copy, PeekPoke)]
+ enum TestEnum {
+ NoArg,
+ OneArg(usize),
+ Args(usize, usize),
+ AnotherNoArg,
+ StructLike { x: usize, y: f32 },
+ }
+ assert_eq!(
+ TestEnum::max_size(),
+ <u8>::max_size() + 2 * <usize>::max_size()
+ );
+}
+
+#[test]
+fn test_enum_cstyle() {
+ #[repr(u32)]
+ #[derive(Clone, Copy, PeekPoke)]
+ enum BorderStyle {
+ None = 0,
+ Solid = 1,
+ Double = 2,
+ Dotted = 3,
+ Dashed = 4,
+ Hidden = 5,
+ Groove = 6,
+ Ridge = 7,
+ Inset = 8,
+ Outset = 9,
+ }
+ assert_eq!(BorderStyle::max_size(), <u8>::max_size());
+}
+
+#[test]
+fn test_phantom_data() {
+ struct Bar;
+ #[derive(PeekPoke)]
+ struct Foo {
+ x: u32,
+ y: u32,
+ _marker: PhantomData<Bar>,
+ }
+ assert_eq!(Foo::max_size(), 2 * size_of::<u32>())
+}
diff --git a/gfx/wr/peek-poke/tests/round_trip.rs b/gfx/wr/peek-poke/tests/round_trip.rs
new file mode 100644
index 0000000000..3134c207ec
--- /dev/null
+++ b/gfx/wr/peek-poke/tests/round_trip.rs
@@ -0,0 +1,275 @@
+// Copyright 2019 The Servo Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use peek_poke::{Peek, PeekPoke, Poke};
+use std::{fmt::Debug, marker::PhantomData};
+
+fn poke_into<V: Peek + Poke>(a: &V) -> Vec<u8> {
+ let mut v = <Vec<u8>>::with_capacity(<V>::max_size());
+ let end_ptr = unsafe { a.poke_into(v.as_mut_ptr()) };
+ let new_size = end_ptr as usize - v.as_ptr() as usize;
+ assert!(new_size <= v.capacity());
+ unsafe {
+ v.set_len(new_size);
+ }
+ v
+}
+
+#[cfg(not(feature = "option_copy"))]
+fn the_same<V>(a: V)
+where
+ V: Debug + Default + PartialEq + Peek + Poke,
+{
+ let v = poke_into(&a);
+ let (b, end_ptr) = unsafe { peek_poke::peek_from_default(v.as_ptr()) };
+ let size = end_ptr as usize - v.as_ptr() as usize;
+ assert_eq!(size, v.len());
+ assert_eq!(a, b);
+}
+
+#[cfg(feature = "option_copy")]
+fn the_same<V>(a: V)
+where
+ V: Copy + Debug + PartialEq + Peek + Poke,
+{
+ let v = poke_into(&a);
+ let mut b = a;
+ let end_ptr = unsafe { b.peek_from(v.as_ptr()) };
+ let size = end_ptr as usize - v.as_ptr() as usize;
+ assert_eq!(size, v.len());
+ assert_eq!(a, b);
+}
+
+#[test]
+fn test_numbers() {
+ // unsigned positive
+ the_same(5u8);
+ the_same(5u16);
+ the_same(5u32);
+ the_same(5u64);
+ the_same(5usize);
+ // signed positive
+ the_same(5i8);
+ the_same(5i16);
+ the_same(5i32);
+ the_same(5i64);
+ the_same(5isize);
+ // signed negative
+ the_same(-5i8);
+ the_same(-5i16);
+ the_same(-5i32);
+ the_same(-5i64);
+ the_same(-5isize);
+ // floating
+ the_same(-100f32);
+ the_same(0f32);
+ the_same(5f32);
+ the_same(-100f64);
+ the_same(5f64);
+}
+
+#[test]
+fn test_bool() {
+ the_same(true);
+ the_same(false);
+}
+
+#[cfg(any(feature = "option_copy", feature = "option_default"))]
+#[test]
+fn test_option() {
+ the_same(Some(5usize));
+ //the_same(Some("foo bar".to_string()));
+ the_same(None::<usize>);
+}
+
+#[test]
+fn test_fixed_size_array() {
+ the_same([24u32; 32]);
+ the_same([1u64, 2, 3, 4, 5, 6, 7, 8]);
+ the_same([0u8; 19]);
+}
+
+#[test]
+fn test_tuple() {
+ the_same((1isize, ));
+ the_same((1isize, 2isize, 3isize));
+ the_same((1isize, ()));
+}
+
+#[test]
+fn test_basic_struct() {
+ #[derive(Copy, Clone, Debug, Default, PartialEq, PeekPoke)]
+ struct Bar {
+ a: u32,
+ b: u32,
+ c: u32,
+ #[cfg(any(feature = "option_copy", feature = "option_default"))]
+ d: Option<u32>,
+ }
+
+ the_same(Bar {
+ a: 2,
+ b: 4,
+ c: 42,
+ #[cfg(any(feature = "option_copy", feature = "option_default"))]
+ d: None,
+ });
+}
+
+#[test]
+fn test_enum() {
+ #[derive(Clone, Copy, Debug, PartialEq, PeekPoke)]
+ enum TestEnum {
+ NoArg,
+ OneArg(usize),
+ Args(usize, usize),
+ AnotherNoArg,
+ StructLike { x: usize, y: f32 },
+ }
+
+ impl Default for TestEnum {
+ fn default() -> Self {
+ TestEnum::NoArg
+ }
+ }
+
+ the_same(TestEnum::NoArg);
+ the_same(TestEnum::OneArg(4));
+ the_same(TestEnum::Args(4, 5));
+ the_same(TestEnum::AnotherNoArg);
+ the_same(TestEnum::StructLike { x: 4, y: 3.14159 });
+}
+
+#[test]
+fn test_enum_cstyle() {
+ #[repr(u32)]
+ #[derive(Clone, Copy, Debug, PartialEq, Eq, PeekPoke)]
+ enum BorderStyle {
+ None = 0,
+ Solid = 1,
+ Double = 2,
+ Dotted = 3,
+ Dashed = 4,
+ Hidden = 5,
+ Groove = 6,
+ Ridge = 7,
+ Inset = 8,
+ Outset = 9,
+ }
+
+ impl Default for BorderStyle {
+ fn default() -> Self {
+ BorderStyle::None
+ }
+ }
+
+ the_same(BorderStyle::None);
+ the_same(BorderStyle::Solid);
+ the_same(BorderStyle::Double);
+ the_same(BorderStyle::Dotted);
+ the_same(BorderStyle::Dashed);
+ the_same(BorderStyle::Hidden);
+ the_same(BorderStyle::Groove);
+ the_same(BorderStyle::Ridge);
+ the_same(BorderStyle::Inset);
+ the_same(BorderStyle::Outset);
+}
+
+#[test]
+fn test_phantom_data() {
+ struct Bar;
+ #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PeekPoke)]
+ struct Foo {
+ x: u32,
+ y: u32,
+ _marker: PhantomData<Bar>,
+ }
+ the_same(Foo {
+ x: 19,
+ y: 42,
+ _marker: PhantomData,
+ });
+}
+
+#[test]
+fn test_generic() {
+ #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PeekPoke)]
+ struct Foo<T> {
+ x: T,
+ y: T,
+ }
+ the_same(Foo { x: 19.0, y: 42.0 });
+}
+
+#[test]
+fn test_generic_enum() {
+ #[derive(Clone, Copy, Debug, Default, PartialEq, PeekPoke)]
+ pub struct PropertyBindingKey<T> {
+ pub id: usize,
+ _phantom: PhantomData<T>,
+ }
+
+ #[derive(Clone, Copy, Debug, PartialEq, PeekPoke)]
+ pub enum PropertyBinding<T> {
+ Value(T),
+ Binding(PropertyBindingKey<T>, T),
+ }
+
+ impl<T: Default> Default for PropertyBinding<T> {
+ fn default() -> Self {
+ PropertyBinding::Value(Default::default())
+ }
+ }
+}
+
+#[cfg(all(feature = "extras", feature = "option_copy"))]
+mod extra_tests {
+ use super::*;
+ use euclid::{Point2D, Rect, SideOffsets2D, Size2D, Transform3D, Vector2D};
+ use std::mem::size_of;
+
+ #[test]
+ fn euclid_types() {
+ the_same(Point2D::<f32>::new(1.0, 2.0));
+ assert_eq!(Point2D::<f32>::max_size(), 2 * size_of::<f32>());
+
+ the_same(Rect::<f32>::new(
+ Point2D::<f32>::new(0.0, 0.0),
+ Size2D::<f32>::new(100.0, 80.0),
+ ));
+ assert_eq!(Rect::<f32>::max_size(), 4 * size_of::<f32>());
+
+ the_same(SideOffsets2D::<f32>::new(0.0, 10.0, -1.0, -10.0));
+ assert_eq!(SideOffsets2D::<f32>::max_size(), 4 * size_of::<f32>());
+
+ the_same(Transform3D::<f32>::identity());
+ assert_eq!(Transform3D::<f32>::max_size(), 16 * size_of::<f32>());
+
+ the_same(Vector2D::<f32>::new(1.0, 2.0));
+ assert_eq!(Vector2D::<f32>::max_size(), 2 * size_of::<f32>());
+ }
+
+ #[test]
+ fn webrender_api_types() {
+ type PipelineSourceId = i32;
+ #[derive(Clone, Copy, Debug, PartialEq, PeekPoke)]
+ struct PipelineId(pub PipelineSourceId, pub u32);
+
+ #[derive(Clone, Copy, Debug, PartialEq, PeekPoke)]
+ struct ClipChainId(pub u64, pub PipelineId);
+
+ #[derive(Clone, Copy, Debug, PartialEq, PeekPoke)]
+ struct SpatialId(pub usize, pub PipelineId);
+
+ the_same(PipelineId(42, 2));
+ the_same(ClipChainId(19u64, PipelineId(42, 2)));
+ the_same(SpatialId(19usize, PipelineId(42, 2)));
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 05:48:54 +0000