tests.unit.BitFieldsTests source code

1 /**
2  * Copyright: Copyright (c) 2017 Wojciech Szęszoł. All rights reserved.
3  * Authors: Wojciech Szęszoł
4  * Version: Initial created: October 22, 2017
5  * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)
6  */
7  module tests.unit.BitFieldsTests;
8 
9 import Common;
10 
11 unittest
12 {
13     assertTranslates(q"C
14 struct Foo
15 {
16     int x : 4;
17 };
18 
19 C",q"D
20 extern (C):
21 
22 struct Foo
23 {
24     import std.bitmanip : bitfields;
25 
26     mixin(bitfields!(
27         int, "x", 4,
28         uint, "", 4));
29 }
30 D");
31 
32 }
33 
34 unittest
35 {
36     assertTranslates(q"C
37 struct Foo
38 {
39     int x : 8;
40 };
41 
42 C",q"D
43 extern (C):
44 
45 struct Foo
46 {
47     import std.bitmanip : bitfields;
48     mixin(bitfields!(int, "x", 8));
49 }
50 D");
51 
52 }
53 
54 
55 unittest
56 {
57     assertTranslates(q"C
58 struct bitfield {
59     unsigned int one : 4;
60     unsigned int two : 8;
61     unsigned int : 4;
62 };
63 C",q"D
64 extern (C):
65 
66 struct bitfield
67 {
68     import std.bitmanip : bitfields;
69 
70     mixin(bitfields!(
71         uint, "one", 4,
72         uint, "two", 8,
73         uint, "", 4));
74 }
75 D");
76 }
77 
78 unittest
79 {
80     assertTranslates(q"C
81 struct Foo {
82     unsigned char a : 3, : 2, b : 6, c : 2;
83 };
84 C",q"D
85 extern (C):
86 
87 struct Foo
88 {
89     import std.bitmanip : bitfields;
90 
91     mixin(bitfields!(
92         ubyte, "a", 3,
93         ubyte, "", 2,
94         ubyte, "b", 6,
95         ubyte, "c", 2,
96         uint, "", 3));
97 }
98 D");
99 
100 };
101 
102 unittest
103 {
104     assertTranslates(q"C
105 struct Foo {
106     short a : 4;
107     char b;
108 };
109 C",q"D
110 extern (C):
111 
112 struct Foo
113 {
114     import std.bitmanip : bitfields;
115 
116     mixin(bitfields!(
117         short, "a", 4,
118         uint, "", 4));
119 
120     char b;
121 }
122 D");
123 
124 };
125 
126 unittest
127 {
128     assertTranslates(q"C
129 struct Foo {
130     short a;
131     char b : 7;
132     char c[1];
133 };
134 C",q"D
135 extern (C):
136 
137 struct Foo
138 {
139     import std.bitmanip : bitfields;
140 
141     short a;
142 
143     mixin(bitfields!(
144         char, "b", 7,
145         uint, "", 1));
146 
147     char[1] c;
148 }
149 D");
150 
151 };
152 
153 unittest
154 {
155     assertTranslates(q"C
156 struct Foo {
157     short a;
158     char b;
159     int c : 1;
160     int d : 4;
161     int e : 7;
162 };
163 C",q"D
164 extern (C):
165 
166 struct Foo
167 {
168     import std.bitmanip : bitfields;
169 
170     short a;
171     char b;
172 
173     mixin(bitfields!(
174         int, "c", 1,
175         int, "d", 4,
176         int, "e", 7,
177         uint, "", 4));
178 }
179 D");
180 
181 };
182 
183 unittest
184 {
185     assertTranslates(q"C
186 struct Foo {
187     short a;
188     int b : 1;
189     int c : 4;
190     int d : 3;
191     int e : 7;
192     int f : 25;
193     char g;
194 };
195 C",q"D
196 extern (C):
197 
198 struct Foo
199 {
200     import std.bitmanip : bitfields;
201 
202     short a;
203 
204     mixin(bitfields!(
205         int, "b", 1,
206         int, "c", 4,
207         int, "d", 3,
208         int, "e", 7,
209         int, "f", 25,
210         uint, "", 24));
211 
212     char g;
213 }
214 D");
215 
216 };
217 
218 unittest
219 {
220     assertTranslates(q"C
221 struct Foo {
222     short a;
223     int b : 1;
224     int c : 4;
225     int d : 3;
226     long e;
227     int f : 7;
228     int g : 25;
229     char h;
230 };
231 C",q"D
232 import core.stdc.config;
233 
234 extern (C):
235 
236 struct Foo
237 {
238     import std.bitmanip : bitfields;
239 
240     short a;
241 
242     mixin(bitfields!(
243         int, "b", 1,
244         int, "c", 4,
245         int, "d", 3));
246 
247     c_long e;
248 
249     mixin(bitfields!(
250         int, "f", 7,
251         int, "g", 25));
252 
253     char h;
254 }
255 D");
256 
257 };