tests/intrusive_shared_ptr_src/abi.size_alignment.cpp

   1 //
   2 // This tests that the alignment and size of a class are the same whether
   3 // they have a `T*` or a shared pointer data member.
   4 //
   5
   6 #include <libkern/c++/intrusive_shared_ptr.h>
   7 #include "test_policy.h"
   8 #include <cstddef>
   9 #include <darwintest.h>
  10
  11
  12 namespace ns1 {
  13 struct FooShared {
  14         test_shared_ptr<int> ptr;
  15 };
  16
  17 struct FooRaw {
  18         int* ptr;
  19 };
  20
  21 static_assert(sizeof(FooShared) == sizeof(FooRaw));
  22 static_assert(alignof(FooShared) == alignof(FooRaw));
  23 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
  24 }
  25
  26 namespace ns2 {
  27 struct FooShared {
  28         int i;
  29         test_shared_ptr<int> ptr;
  30 };
  31
  32 struct FooRaw {
  33         int i;
  34         int* ptr;
  35 };
  36
  37 static_assert(sizeof(FooShared) == sizeof(FooRaw));
  38 static_assert(alignof(FooShared) == alignof(FooRaw));
  39 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
  40 }
  41
  42 namespace ns3 {
  43 struct FooShared {
  44         char c;
  45         test_shared_ptr<int> ptr;
  46         int i;
  47 };
  48
  49 struct FooRaw {
  50         char c;
  51         int* ptr;
  52         int i;
  53 };
  54
  55 static_assert(sizeof(FooShared) == sizeof(FooRaw));
  56 static_assert(alignof(FooShared) == alignof(FooRaw));
  57 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
  58 }
  59
  60 namespace ns4 {
  61 struct FooShared {
  62         char c;
  63         unsigned int b : 5;
  64         test_shared_ptr<int> ptr;
  65         int i;
  66 };
  67
  68 struct FooRaw {
  69         char c;
  70         unsigned int b : 5;
  71         int* ptr;
  72         int i;
  73 };
  74
  75 static_assert(sizeof(FooShared) == sizeof(FooRaw));
  76 static_assert(alignof(FooShared) == alignof(FooRaw));
  77 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
  78 }
  79
  80 namespace ns5 {
  81 struct __attribute__((packed)) FooShared {
  82         char c;
  83         unsigned int b : 5;
  84         test_shared_ptr<int> ptr;
  85         int i;
  86 };
  87
  88 struct __attribute__((packed)) FooRaw {
  89         char c;
  90         unsigned int b : 5;
  91         int* ptr;
  92         int i;
  93 };
  94
  95 static_assert(sizeof(FooShared) == sizeof(FooRaw));
  96 static_assert(alignof(FooShared) == alignof(FooRaw));
  97 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
  98 }
  99
 100 namespace ns6 {
 101 struct FooShared {
 102         char c;
 103         unsigned int b : 5;
 104         test_shared_ptr<int> ptr;
 105         int i __attribute__((packed));
 106 };
 107
 108 struct FooRaw {
 109         char c;
 110         unsigned int b : 5;
 111         int* ptr;
 112         int i __attribute__((packed));
 113 };
 114
 115 static_assert(sizeof(FooShared) == sizeof(FooRaw));
 116 static_assert(alignof(FooShared) == alignof(FooRaw));
 117 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
 118 }
 119
 120 namespace ns7 {
 121 struct FooShared {
 122         char c;
 123         unsigned int b : 5;
 124         test_shared_ptr<int> ptr __attribute__((packed));
 125         int i;
 126 };
 127
 128 struct FooRaw {
 129         char c;
 130         unsigned int b : 5;
 131         int* ptr __attribute__((packed));
 132         int i;
 133 };
 134
 135 static_assert(sizeof(FooShared) == sizeof(FooRaw));
 136 static_assert(alignof(FooShared) == alignof(FooRaw));
 137 static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
 138 }
 139
 140 T_DECL(abi_size_alignment, "intrusive_shared_ptr.abi.size_alignment") {
 141         T_PASS("intrusive_shared_ptr.abi.size_alignment compile-time tests passed");
 142 }