File: dlfcn-api-tests.c

package info (click to toggle)
mmlib 1.4.2-2.1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 1,716 kB
  • sloc: ansic: 18,071; makefile: 431; sh: 135; python: 63
file content (197 lines) | stat: -rw-r--r-- 4,320 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
/*
   @mindmaze_header@
 */
#if defined (HAVE_CONFIG_H)
# include <config.h>
#endif

#include <check.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <mmdlfcn.h>
#include <mmerrno.h>

#include "api-testcases.h"
#include "dynlib-api.h"

#define TEST_VAL 0x1f2f3f4f


START_TEST(dlopen_simple)
{
	mm_dynlib_t * hndl = mm_dlopen(LT_OBJDIR "/dynlib-test" LT_MODULE_EXT,
	                              MM_LD_NOW);
	ck_assert(hndl != NULL);
	mm_dlclose(hndl);
}
END_TEST

START_TEST(dlopen_invalid_flags)
{
	mm_dynlib_t * hndl = mm_dlopen(LT_OBJDIR "/dynlib-test" LT_MODULE_EXT,
	                              MM_LD_NOW | MM_LD_LAZY);
	ck_assert(hndl == NULL);
	ck_assert(mm_get_lasterror_number() == EINVAL);
	mm_dlclose(hndl);
}
END_TEST

START_TEST(dlopen_invalid_path)
{
	mm_dynlib_t * hndl = mm_dlopen("invalid-path-name",
	                              MM_LD_NOW | MM_LD_LAZY);
	ck_assert(hndl == NULL);
	ck_assert(mm_get_lasterror_number() == EINVAL);
	mm_dlclose(hndl);
}
END_TEST

START_TEST(dlsym_simple)
{
	mm_dynlib_t * hndl = mm_dlopen(LT_OBJDIR "/dynlib-test" LT_MODULE_EXT,
	                              MM_LD_NOW);
	ck_assert(hndl != NULL);
	ck_assert(mm_dlsym(hndl, "api") != NULL);
	mm_dlclose(hndl);
}
END_TEST

START_TEST(dlsym_invalid)
{
	ck_assert(mm_dlsym(NULL, "invalid-symbol-name") == NULL);
	ck_assert(mm_get_lasterror_number() == EINVAL);


	mm_dynlib_t * hndl = mm_dlopen(LT_OBJDIR "/dynlib-test" LT_MODULE_EXT,
	                              MM_LD_NOW);
	ck_assert(hndl != NULL);

	ck_assert(mm_dlsym(hndl, NULL) == NULL);
	ck_assert(mm_get_lasterror_number() == EINVAL);

	mm_dlclose(hndl);
}
END_TEST

START_TEST(dlsym_not_found)
{
	mm_dynlib_t * hndl = mm_dlopen(LT_OBJDIR "/dynlib-test" LT_MODULE_EXT,
	                              MM_LD_NOW);
	ck_assert(hndl != NULL);
	ck_assert(mm_dlsym(hndl, "invalid-symbol-name") == NULL);
	mm_dlclose(hndl);
}
END_TEST

START_TEST(dl_fileext_test)
{
#ifdef LT_MODULE_EXT
	ck_assert(strncmp(mm_dl_fileext(), LT_MODULE_EXT,
	                  sizeof(LT_MODULE_EXT)) == 0);
#endif
	return;
}
END_TEST

static
bool check_dynlibdata_val(struct dynlib_data* data,
                          int expected_ival, const char* expected_str)
{
	if ((data->intval != expected_ival)
	   || (strcmp(data->str, expected_str) != 0) )
		return false;

	return true;
}

static
int run_plugin_tests(const char* plugin, int flags)
{
	mm_dynlib_t* libhnd;
	struct dynlib_data* data;
	struct dynlib_vtab* vtab;

	libhnd = mm_dlopen(plugin, flags);
	if (!libhnd)
		goto error;

	// Test symbol loading
	if (!(data = mm_dlsym(libhnd, "libdata"))
	   || !(vtab = mm_dlsym(libhnd, "api")) )
		goto error;

	// Test initial values
	if (!check_dynlibdata_val(data, INITIAL_INTVAL, INITIAL_STR)
	   || (vtab->read_internal_code() != 0) ) {
		mm_raise_error(MM_EWRONGSTATE, "Wrong initial values");
		goto error;
	}

	vtab->set_internal_code(TEST_VAL);
	if (vtab->read_internal_code() != TEST_VAL) {
		mm_raise_error(MM_EWRONGSTATE, "copied values do not match");
		goto error;
	}

	vtab->set_data(-2, "test");
	if (!check_dynlibdata_val(data, -2, "test")) {
		mm_raise_error(MM_EWRONGSTATE, "values not set in libdata");
		goto error;
	}

	vtab->reset_data();
	if (!check_dynlibdata_val(data, INITIAL_INTVAL, INITIAL_STR) ) {
		mm_raise_error(MM_EWRONGSTATE, "Wrong value reset");
		goto error;
	}

	mm_dlclose(libhnd);
	return 0;

error:
	fprintf(stderr, "run_plugin_tests(\"%s\", %08x) failed: %s",
	        plugin, flags, mm_get_lasterror_desc());
	if (libhnd)
		mm_dlclose(libhnd);

	return -1;
}


START_TEST(plugin_lt_module_ext)
{
	ck_assert(run_plugin_tests(LT_OBJDIR "/dynlib-test" LT_MODULE_EXT, 0) ==
	          0);
}
END_TEST

START_TEST(plugin_ld_append_ext)
{
	ck_assert(run_plugin_tests(LT_OBJDIR "/dynlib-test", MM_LD_APPEND_EXT) ==
	          0);
}
END_TEST

LOCAL_SYMBOL
TCase* create_dlfcn_tcase(void)
{
	TCase * tc;

	tc = tcase_create("dlfcn");

	tcase_add_test(tc, dlopen_simple);
	tcase_add_test(tc, dlopen_invalid_flags);
	tcase_add_test(tc, dlopen_invalid_path);
	tcase_add_test(tc, dlsym_simple);
	tcase_add_test(tc, dlsym_invalid);
	tcase_add_test(tc, dlsym_not_found);
	tcase_add_test(tc, dl_fileext_test);

	tcase_add_test(tc, plugin_lt_module_ext);
	tcase_add_test(tc, plugin_ld_append_ext);

	return tc;
}