Update tests

Author: lucic71

tests/unit/concepts.cpp

@@ -7,8 +7,19 @@ concept Small = sizeof(T) <= 4;
 
 static_assert(Small<int>);
 
+template <typename T>
+concept HasSize = requires(T t) {
+  { t.size() } -> std::same_as<int>;
+};
+
+struct Sized {
+  int size() { return 4; }
+};
+
 template <typename T> bool is_small() { return Small<T>; }
 
+template <typename T> bool has_size() { return requires(T t) { t.size(); }; }
+
 template <typename T> int pick(T x) {
   if (std::integral<T> && Small<T>) {
     return 1;
@@ -20,6 +31,10 @@ int main() {
   static_assert(!Small<long>);
   assert(is_small<char>());
   assert(!is_small<double>());
+  assert(HasSize<Sized>);
+  assert(!HasSize<int>);
+  assert(has_size<Sized>());
+  assert(!has_size<int>());
   assert(pick(1) == 1);
   assert(pick(1L) == 2);
   assert(pick(1.0f) == 2);

tests/unit/out/refcount/concepts.rs

@@ -6,27 +6,51 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct Sized {}
+impl Clone for Sized {
+    fn clone(&self) -> Self {
+        let __this: Value<Sized> = Rc::new(RefCell::new(Self {}));
+        let this: Ptr<Sized> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Sized {
+    fn byte_size() -> usize {
+        1
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {}
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {}
+    }
+}
 pub fn is_small_0() -> bool {
     return true;
 }
 pub fn is_small_1() -> bool {
     return false;
 }
-pub fn pick_2(x: i32) -> i32 {
+pub fn has_size_2() -> bool {
+    return true;
+}
+pub fn has_size_3() -> bool {
+    return false;
+}
+pub fn pick_4(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     if (true) && (true) {
         return 1;
     }
     return 2;
 }
-pub fn pick_3(x: i64) -> i32 {
+pub fn pick_5(x: i64) -> i32 {
     let x: Value<i64> = Rc::new(RefCell::new(x));
     if (true) && (false) {
         return 1;
     }
     return 2;
 }
-pub fn pick_4(x: f32) -> i32 {
+pub fn pick_6(x: f32) -> i32 {
     let x: Value<f32> = Rc::new(RefCell::new(x));
     if (false) && (true) {
         return 1;
@@ -39,8 +63,20 @@ pub fn main() {
 fn main_0() -> i32 {
     assert!(({ is_small_0() }));
     assert!(!({ is_small_1() }));
-    assert!((({ pick_2(1,) }) == 1));
-    assert!((({ pick_3(1_i64,) }) == 2));
-    assert!((({ pick_4(1.0E+0,) }) == 2));
+    assert!(true);
+    assert!(!false);
+    assert!(({ has_size_2() }));
+    assert!(!({ has_size_3() }));
+    assert!((({ pick_4(1,) }) == 1));
+    assert!((({ pick_5(1_i64,) }) == 2));
+    assert!((({ pick_6(1.0E+0,) }) == 2));
     return 0;
 }
+pub trait SizedImpl {
+    fn size(&self) -> i32;
+}
+impl SizedImpl for Ptr<Sized> {
+    fn size(&self) -> i32 {
+        return 4;
+    }
+}

tests/unit/out/unsafe/concepts.rs

@@ -6,25 +6,39 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Sized {}
+impl Sized {
+    pub unsafe fn size(&mut self) -> i32 {
+        return 4;
+    }
+}
 pub unsafe fn is_small_0() -> bool {
     return true;
 }
 pub unsafe fn is_small_1() -> bool {
     return false;
 }
-pub unsafe fn pick_2(mut x: i32) -> i32 {
+pub unsafe fn has_size_2() -> bool {
+    return true;
+}
+pub unsafe fn has_size_3() -> bool {
+    return false;
+}
+pub unsafe fn pick_4(mut x: i32) -> i32 {
     if (true) && (true) {
         return 1;
     }
     return 2;
 }
-pub unsafe fn pick_3(mut x: i64) -> i32 {
+pub unsafe fn pick_5(mut x: i64) -> i32 {
     if (true) && (false) {
         return 1;
     }
     return 2;
 }
-pub unsafe fn pick_4(mut x: f32) -> i32 {
+pub unsafe fn pick_6(mut x: f32) -> i32 {
     if (false) && (true) {
         return 1;
     }
@@ -38,8 +52,12 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     assert!((unsafe { is_small_0() }));
     assert!(!(unsafe { is_small_1() }));
-    assert!(((unsafe { pick_2(1,) }) == (1)));
-    assert!(((unsafe { pick_3(1_i64,) }) == (2)));
-    assert!(((unsafe { pick_4(1.0E+0,) }) == (2)));
+    assert!(true);
+    assert!(!false);
+    assert!((unsafe { has_size_2() }));
+    assert!(!(unsafe { has_size_3() }));
+    assert!(((unsafe { pick_4(1,) }) == (1)));
+    assert!(((unsafe { pick_5(1_i64,) }) == (2)));
+    assert!(((unsafe { pick_6(1.0E+0,) }) == (2)));
     return 0;
 }