1 #include <glib-object.h>
2
3 static const GEnumValue my_enum_values[] =
4 {
5 { 1, "the first value", "one" },
6 { 2, "the second value", "two" },
7 { 3, "the third value", "three" },
8 { 0, NULL, NULL }
9 };
10
11 static void
12 test_enum_basic (void)
13 {
14 GType type;
15 GEnumClass *class;
16 GEnumValue *val;
17 GValue value = G_VALUE_INIT;
18 gchar *to_string;
19
20 type = g_enum_register_static ("MyEnum", my_enum_values);
21
22 g_value_init (&value, type);
23 g_assert_true (G_VALUE_HOLDS_ENUM (&value));
24
25 g_value_set_enum (&value, 2);
26 g_assert_cmpint (g_value_get_enum (&value), ==, 2);
27 g_value_unset (&value);
28
29 class = g_type_class_ref (type);
30
31 g_assert_cmpint (class->minimum, ==, 1);
32 g_assert_cmpint (class->maximum, ==, 3);
33 g_assert_cmpint (class->n_values, ==, 3);
34
35 val = g_enum_get_value (class, 2);
36 g_assert_nonnull (val);
37 g_assert_cmpstr (val->value_name, ==, "the second value");
38 val = g_enum_get_value (class, 15);
39 g_assert_null (val);
40
41 val = g_enum_get_value_by_name (class, "the third value");
42 g_assert_nonnull (val);
43 g_assert_cmpint (val->value, ==, 3);
44 val = g_enum_get_value_by_name (class, "the color purple");
45 g_assert_null (val);
46
47 val = g_enum_get_value_by_nick (class, "one");
48 g_assert_nonnull (val);
49 g_assert_cmpint (val->value, ==, 1);
50 val = g_enum_get_value_by_nick (class, "purple");
51 g_assert_null (val);
52
53 to_string = g_enum_to_string (type, 2);
54 g_assert_cmpstr (to_string, ==, "the second value");
55 g_free (to_string);
56
57 to_string = g_enum_to_string (type, 15);
58 g_assert_cmpstr (to_string, ==, "15");
59 g_free (to_string);
60
61 g_type_class_unref (class);
62 }
63
64 static const GFlagsValue my_flag_values[] =
65 {
66 { 0, "no flags", "none" },
67 { 1, "the first flag", "one" },
68 { 2, "the second flag", "two" },
69 { 8, "the third flag", "three" },
70 { 0, NULL, NULL }
71 };
72
73 static const GFlagsValue no_default_flag_values[] =
74 {
75 { 1, "the first flag", "one" },
76 { 0, NULL, NULL }
77 };
78
79 static void
80 test_flags_transform_to_string (const GValue *value)
81 {
82 GValue tmp = G_VALUE_INIT;
83
84 g_value_init (&tmp, G_TYPE_STRING);
85 g_value_transform (value, &tmp);
86 g_value_unset (&tmp);
87 }
88
89 static void
90 test_flags_basic (void)
91 {
92 GType type, no_default_type;
93 GFlagsClass *class;
94 GFlagsValue *val;
95 GValue value = G_VALUE_INIT;
96 gchar *to_string;
97
98 type = g_flags_register_static ("MyFlags", my_flag_values);
99 no_default_type = g_flags_register_static ("NoDefaultFlags",
100 no_default_flag_values);
101
102 g_value_init (&value, type);
103 g_assert_true (G_VALUE_HOLDS_FLAGS (&value));
104
105 g_value_set_flags (&value, 2|8);
106 g_assert_cmpint (g_value_get_flags (&value), ==, 2|8);
107
108 class = g_type_class_ref (type);
109
110 g_assert_cmpint (class->mask, ==, 1|2|8);
111 g_assert_cmpint (class->n_values, ==, 4);
112
113 val = g_flags_get_first_value (class, 2|8);
114 g_assert_nonnull (val);
115 g_assert_cmpstr (val->value_name, ==, "the second flag");
116 val = g_flags_get_first_value (class, 16);
117 g_assert_null (val);
118
119 val = g_flags_get_value_by_name (class, "the third flag");
120 g_assert_nonnull (val);
121 g_assert_cmpint (val->value, ==, 8);
122 val = g_flags_get_value_by_name (class, "the color purple");
123 g_assert_null (val);
124
125 val = g_flags_get_value_by_nick (class, "one");
126 g_assert_nonnull (val);
127 g_assert_cmpint (val->value, ==, 1);
128 val = g_flags_get_value_by_nick (class, "purple");
129 g_assert_null (val);
130
131 test_flags_transform_to_string (&value);
132 g_value_unset (&value);
133
134 to_string = g_flags_to_string (type, 1|8);
135 g_assert_cmpstr (to_string, ==, "the first flag | the third flag");
136 g_free (to_string);
137
138 to_string = g_flags_to_string (type, 0);
139 g_assert_cmpstr (to_string, ==, "no flags");
140 g_free (to_string);
141
142 to_string = g_flags_to_string (type, 16);
143 g_assert_cmpstr (to_string, ==, "0x10");
144 g_free (to_string);
145
146 to_string = g_flags_to_string (type, 1|16);
147 g_assert_cmpstr (to_string, ==, "the first flag | 0x10");
148 g_free (to_string);
149
150 to_string = g_flags_to_string (no_default_type, 0);
151 g_assert_cmpstr (to_string, ==, "0x0");
152 g_free (to_string);
153
154 to_string = g_flags_to_string (no_default_type, 16);
155 g_assert_cmpstr (to_string, ==, "0x10");
156 g_free (to_string);
157
158 g_type_class_unref (class);
159 }
160
161 typedef enum {
162 TEST_ENUM_FIRST_VALUE,
163 TEST_ENUM_SECOND_VALUE,
164 TEST_ENUM_THIRD_VALUE
165 } TestEnum;
166
167 GType test_enum_get_type (void);
168
169 G_DEFINE_ENUM_TYPE (TestEnum, test_enum,
170 G_DEFINE_ENUM_VALUE (TEST_ENUM_FIRST_VALUE, "first-value"),
171 G_DEFINE_ENUM_VALUE (TEST_ENUM_SECOND_VALUE, "second-value"),
172 G_DEFINE_ENUM_VALUE (TEST_ENUM_THIRD_VALUE, "third-value"))
173
174 static void
175 test_enum_define_type (void)
176 {
177 GEnumClass *class = g_type_class_ref (test_enum_get_type ());
178 GEnumValue *val;
179
180 g_assert_cmpint (class->minimum, ==, 0);
181 g_assert_cmpint (class->maximum, ==, 2);
182 g_assert_cmpint (class->n_values, ==, 3);
183
184 val = g_enum_get_value (class, 2);
185 g_assert_nonnull (val);
186 g_assert_cmpstr (val->value_nick, ==, "third-value");
187 val = g_enum_get_value (class, 15);
188 g_assert_null (val);
189
190 g_type_class_unref (class);
191 }
192
193 typedef enum {
194 TEST_FLAGS_DEFAULT = 0,
195 TEST_FLAGS_FIRST = 1 << 0,
196 TEST_FLAGS_SECOND = 1 << 1,
197 TEST_FLAGS_THIRD = 1 << 2
198 } TestFlags;
199
200 GType test_flags_get_type (void);
201
202 G_DEFINE_FLAGS_TYPE (TestFlags, test_flags,
203 G_DEFINE_ENUM_VALUE (TEST_FLAGS_DEFAULT, "default"),
204 G_DEFINE_ENUM_VALUE (TEST_FLAGS_FIRST, "first"),
205 G_DEFINE_ENUM_VALUE (TEST_FLAGS_SECOND, "second"),
206 G_DEFINE_ENUM_VALUE (TEST_FLAGS_THIRD, "third"))
207
208 static void
209 test_flags_define_type (void)
210 {
211 GFlagsClass *class = g_type_class_ref (test_flags_get_type ());
212 GFlagsValue *val;
213 char *to_string;
214
215 g_assert_cmpint (class->mask, ==, 1 | 2 | 4);
216 g_assert_cmpint (class->n_values, ==, 4);
217
218 val = g_flags_get_first_value (class, 2|4);
219 g_assert_nonnull (val);
220 g_assert_cmpstr (val->value_nick, ==, "second");
221
222 val = g_flags_get_first_value (class, 8);
223 g_assert_null (val);
224
225 to_string = g_flags_to_string (test_flags_get_type (), 0);
226 g_assert_cmpstr (to_string, ==, "TEST_FLAGS_DEFAULT");
227 g_free (to_string);
228
229 g_type_class_unref (class);
230 }
231
232 int
233 main (int argc, char *argv[])
234 {
235 g_test_init (&argc, &argv, NULL);
236
237 g_test_add_func ("/enum/basic", test_enum_basic);
238 g_test_add_func ("/enum/define-type", test_enum_define_type);
239 g_test_add_func ("/flags/basic", test_flags_basic);
240 g_test_add_func ("/flags/define-type", test_flags_define_type);
241
242 return g_test_run ();
243 }