[apple/xnu.git] / tests / intrusive_shared_ptr_src / abi.size_alignment.cpp

//
// This tests that the alignment and size of a class are the same whether
// they have a `T*` or a shared pointer data member.
//

#include <libkern/c++/intrusive_shared_ptr.h>
#include "test_policy.h"
#include <cstddef>
#include <darwintest.h>


namespace ns1 {
struct FooShared {
	test_shared_ptr<int> ptr;
};

struct FooRaw {
	int* ptr;
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

namespace ns2 {
struct FooShared {
	int i;
	test_shared_ptr<int> ptr;
};

struct FooRaw {
	int i;
	int* ptr;
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

namespace ns3 {
struct FooShared {
	char c;
	test_shared_ptr<int> ptr;
	int i;
};

struct FooRaw {
	char c;
	int* ptr;
	int i;
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

namespace ns4 {
struct FooShared {
	char c;
	unsigned int b : 5;
	test_shared_ptr<int> ptr;
	int i;
};

struct FooRaw {
	char c;
	unsigned int b : 5;
	int* ptr;
	int i;
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

namespace ns5 {
struct __attribute__((packed)) FooShared {
	char c;
	unsigned int b : 5;
	test_shared_ptr<int> ptr;
	int i;
};

struct __attribute__((packed)) FooRaw {
	char c;
	unsigned int b : 5;
	int* ptr;
	int i;
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

namespace ns6 {
struct FooShared {
	char c;
	unsigned int b : 5;
	test_shared_ptr<int> ptr;
	int i __attribute__((packed));
};

struct FooRaw {
	char c;
	unsigned int b : 5;
	int* ptr;
	int i __attribute__((packed));
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

namespace ns7 {
struct FooShared {
	char c;
	unsigned int b : 5;
	test_shared_ptr<int> ptr __attribute__((packed));
	int i;
};

struct FooRaw {
	char c;
	unsigned int b : 5;
	int* ptr __attribute__((packed));
	int i;
};

static_assert(sizeof(FooShared) == sizeof(FooRaw));
static_assert(alignof(FooShared) == alignof(FooRaw));
static_assert(offsetof(FooShared, ptr) == offsetof(FooRaw, ptr));
}

T_DECL(abi_size_alignment, "intrusive_shared_ptr.abi.size_alignment") {
	T_PASS("intrusive_shared_ptr.abi.size_alignment compile-time tests passed");
}
Commit	Line	Data
f427ee49 A	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	}