int
main(int argc, char *argv[])
{
char * tst;
char * expected;
test_init("ompi_numtostr_t");
tst = opal_ltostr(10);
expected = malloc(sizeof(long) * 8);
snprintf(expected, sizeof(long) * 8, "%d", 10);
if (strcmp(tst, expected) != 0) {
test_failure("opal_ltostr test failed");
}
else {
test_success();
}
free(tst);
free(expected);
tst = opal_dtostr(5.32);
expected = malloc(sizeof(long) * 8);
snprintf(expected, sizeof(long) * 8, "%f", 5.32);
if (strcmp(tst, expected) != 0) {
test_failure("opal_dtostr test failed");
}
else {
test_success();
}
test_finalize();
return 0;
}
int main(int argc, char* argv[])
{
opal_init(&argc, &argv);
test_init("opal_os_create_dirpath_t");
/* All done */
if (test1()) {
test_success();
}
else {
test_failure("opal_os_create_dirpath test1 failed");
}
if (test2()) {
test_success();
}
else {
test_failure("opal_os_create_dirpath test2 failed");
}
if (test3()) {
test_success();
}
else {
test_failure("opal_os_create_dirpath test3 failed");
}
test_finalize();
opal_finalize();
return 0;
}
void test_get_temporary_buffer (T *dummy, const char *tname)
{
RW_ASSERT (0 != tname);
test_success (dummy, tname);
test_failure (dummy, tname);
}
DEF_TEST(SkSLInvalidUnary, r) {
test_failure(r,
"void main() { mat4 x = mat4(1); ++x; }",
"error: 1: '++' cannot operate on 'mat4'\n1 error\n");
test_failure(r,
"void main() { vec3 x = vec3(1); --x; }",
"error: 1: '--' cannot operate on 'vec3'\n1 error\n");
test_failure(r,
"void main() { mat4 x = mat4(1); x++; }",
"error: 1: '++' cannot operate on 'mat4'\n1 error\n");
test_failure(r,
"void main() { vec3 x = vec3(1); x--; }",
"error: 1: '--' cannot operate on 'vec3'\n1 error\n");
test_failure(r,
"void main() { int x = !12; }",
"error: 1: '!' cannot operate on 'int'\n1 error\n");
test_failure(r,
"struct foo { } bar; void main() { foo x = +bar; }",
"error: 1: '+' cannot operate on 'foo'\n1 error\n");
test_failure(r,
"struct foo { } bar; void main() { foo x = -bar; }",
"error: 1: '-' cannot operate on 'foo'\n1 error\n");
test_success(r,
"void main() { vec2 x = vec2(1, 1); x = +x; x = -x; }");
}
DEF_TEST(SkSLStaticSwitch, r) {
test_success(r,
"void main() {"
"int x = 1;"
"@switch (x) {"
"case 1: sk_FragColor = vec4(1); break;"
"default: sk_FragColor = vec4(0);"
"}"
"}");
test_failure(r,
"void main() {"
"int x = int(sqrt(1));"
"@switch (x) {"
"case 1: sk_FragColor = vec4(1); break;"
"default: sk_FragColor = vec4(0);"
"}"
"}",
"error: 1: static switch has non-static test\n1 error\n");
test_failure(r,
"void main() {"
"int x = 1;"
"@switch (x) {"
"case 1: sk_FragColor = vec4(1); if (sqrt(0) < sqrt(1)) break;"
"default: sk_FragColor = vec4(0);"
"}"
"}",
"error: 1: static switch contains non-static conditional break\n1 error\n");
}
static int
test_cbpool(void)
{
test_start("cbpool");
cbpool_t p;
cbpool_init(&p, 1024);
int obj[16];
for (int i = 0; i < 16; i++) {
obj[i] = cbpool_alloc(&p, 32);
test_assert(obj[i] >= 0 && obj[i] <= 1024);
for (int j = 0; j < 32; j++) {
test_assert(cbpool_check_single(&p, i + j) == true);
}
}
for (int i = 0; i < 16; i++) {
cbpool_free(&p, obj[i], 32);
}
uint32_t v = cbpool_alloc(&p, 1024);
test_assert(v == 0);
for (int i = 0; i < 1024; i+=2) {
test_assert(cbpool_check_single(&p, i) == true);
cbpool_set_single(&p, i, false);
test_assert(cbpool_check_single(&p, i) == false);
cbpool_set_single(&p, i, true);
test_assert(cbpool_check_single(&p, i) == true);
}
cbpool_release(&p);
return test_success();
}
DEF_TEST(SkSLDuplicateFunction, r) {
test_failure(r,
"void main() { } void main() { }",
"error: 1: duplicate definition of void main()\n1 error\n");
test_success(r,
"void main(); void main() { }");
}
static void
test_filter_or_format(enabler enable)
{
test_success(archive_read_new, enable, archive_read_free);
test_failure(archive_write_new, enable, archive_write_free);
test_failure(archive_read_disk_new, enable, archive_read_free);
test_failure(archive_write_disk_new, enable, archive_write_free);
}
DEF_TEST(SkSLStaticIf, r) {
test_success(r,
"void main() { float x = 5; float y = 10;"
"@if (x < y) { sk_FragColor = vec4(1); } }");
test_failure(r,
"void main() { float x = sqrt(25); float y = 10;"
"@if (x < y) { sk_FragColor = vec4(1); } }",
"error: 1: static if has non-static test\n1 error\n");
}
int
test_vspace(int run)
{
test_start(run == 0 ? "vspace (run 1)" : "vspace (run 2)");
const int numTestVS = MIN(8, MIN((PID_MAX - 1), PD_MAX));
int error = -1;
struct vs_vspace vs[numTestVS];
/* Allocate ALL the vspaces. */
for (int i = 0; i < numTestVS; i++) {
uint32_t bogusPID = (i * 31337 % 1234);
error = vs_initialise(&vs[i], bogusPID);
test_assert(error == ESUCCESS);
test_assert(vs[i].magic == REFOS_VSPACE_MAGIC);
test_assert(vs[i].ref == 1);
test_assert(vs[i].pid == bogusPID);
test_assert(vs[i].kpd != 0);
test_assert(vs[i].cspace.capPtr != 0);
test_assert(vs[i].cspaceSize == REFOS_CSPACE_RADIX);
}
/* Ref every second one thrice. */
for (int i = 0; i < numTestVS; i+=2) {
vs_ref(&vs[i]);
vs_ref(&vs[i]);
vs_ref(&vs[i]);
}
/* Deref every VS. */
for (int i = 0; i < numTestVS; i++) {
vs_unref(&vs[i]);
}
/* Check that every second one is still alive. */
for (int i = 0; i < numTestVS; i++) {
if (i % 2 == 0) {
test_assert(vs[i].ref == 3);
test_assert(vs[i].magic == REFOS_VSPACE_MAGIC);
vs_unref(&vs[i]);
test_assert(vs[i].ref == 2);
test_assert(vs[i].magic == REFOS_VSPACE_MAGIC);
vs_unref(&vs[i]);
test_assert(vs[i].ref == 1);
test_assert(vs[i].magic == REFOS_VSPACE_MAGIC);
vs_unref(&vs[i]);
test_assert(vs[i].ref == 0);
test_assert(vs[i].magic != REFOS_VSPACE_MAGIC);
} else {
test_assert(vs[i].ref == 0);
test_assert(vs[i].magic != REFOS_VSPACE_MAGIC);
}
}
return test_success();
}
int main(int argc, char* argv[])
{
test_init("opal_argv_t");
if( test1() ) test_success();
else test_failure("test1 argv test failed");
if( test2() ) test_success();
else test_failure("test2 argv test failed");
if( test3() ) test_success();
else test_failure("test3 argv test failed");
if( test4() ) test_success();
else test_failure("test4 argv test failed");
if( test5() ) test_success();
else test_failure("test5 argv test failed");
if( test6() ) test_success();
else test_failure("test6 argv test failed");
if( test7() ) test_success();
else test_failure("test7 argv test failed");
if( test8() ) test_success();
else test_failure("test8 argv test failed");
if (test9()) {
test_success();
} else {
test_failure("test9 argv test failed");
}
if (test10()) {
test_success();
} else {
test_failure("test10 argv test failed");
}
/* All done */
return test_finalize();
}
DEF_TEST(SkSLGenericArgumentMismatch, r) {
test_failure(r,
"void main() { float x = sin(1, 2); }",
"error: 1: call to 'sin' expected 1 argument, but found 2\n1 error\n");
test_failure(r,
"void main() { float x = sin(true); }",
"error: 1: no match for sin(bool)\n1 error\n");
test_success(r,
"void main() { float x = sin(1); }");
}
DEF_TEST(SkSLDuplicateSymbol, r) {
test_failure(r,
"int main; void main() { }",
"error: 1: symbol 'main' was already defined\n1 error\n");
test_failure(r,
"int x; int x; void main() { }",
"error: 1: symbol 'x' was already defined\n1 error\n");
test_success(r, "int x; void main() { int x; }");
}
static void test_req_sent(struct network_test *t)
{
int s = t->nt_s;
fd_set fds;
struct timeval tv;
char buf[1024];
int rc;
FD_ZERO(&fds);
FD_SET(s, &fds);
tv.tv_sec = 0;
tv.tv_usec = 0;
if (select(s + 1, &fds, NULL, NULL, &tv) == -1)
err(1, "select()");
if (!FD_ISSET(s, &fds))
return;
rc = recv(s, buf, sizeof(buf) - 1, 0);
if (rc == -1) {
test_finish(t, errno);
return;
}
if (rc == 0) {
test_finish(t, TEST_ERR_DISCONNECT);
return;
}
buf[rc] = 0;
if (strncmp(buf, TEST_REPLY, strlen(TEST_REPLY)) != 0) {
test_finish(t, TEST_ERR_BADINPUT);
return;
}
t->nt_flags = atoi(&buf[rc - 1]);
if (t->nt_proto == TEST_TCP && t->nt_crypt == 1) {
test_finish(t, TEST_ERR_UNEXPECTED_CRYPT);
return;
}
if (t->nt_proto == TEST_CRYPT && t->nt_crypt != 1) {
test_finish(t, TEST_ERR_NO_CRYPT);
return;
}
test_success(t);
}
void doit(void)
{
global_init();
gnutls_global_set_log_function(tls_log_func);
if (debug)
gnutls_global_set_log_level(99);
test_failure_client();
test_failure_server();
test_success();
gnutls_global_deinit();
}
DEF_TEST(SkSLAssignmentTypeMismatch, r) {
test_failure(r,
"void main() { int x = 1.0; }",
"error: 1: expected 'int', but found 'float'\n1 error\n");
test_failure(r,
"void main() { int x; x = 1.0; }",
"error: 1: type mismatch: '=' cannot operate on 'int', 'float'\n1 error\n");
test_success(r,
"void main() { vec3 x = vec3(0); x *= 1.0; }");
test_failure(r,
"void main() { ivec3 x = ivec3(0); x *= 1.0; }",
"error: 1: type mismatch: '*=' cannot operate on 'ivec3', 'float'\n1 error\n");
}
static int
test_file_server_serv_connect()
{
test_start("fs serv_connect");
for (int i = 0; i < 5; i++) {
serv_connection_t c = serv_connect("/fileserv/*");
test_assert(c.error == ESUCCESS);
test_assert(c.paramBuffer.err == ESUCCESS);
strcpy(c.paramBuffer.vaddr, "test");
serv_disconnect(&c);
}
return test_success();
}
void test(char* file, bool expect)
{
#ifdef DEBUG
printf ("test(): file:%s bool:%d\n",
file, expect);
#endif
if (expect == opal_path_nfs (file, NULL)) {
test_success();
} else {
char * msg;
opal_asprintf(&msg, "Mismatch: input \"%s\", expected:%d got:%d\n",
file, expect, !expect);
test_failure(msg);
free(msg);
}
}
static int
test_cpool(void)
{
test_start("cpool");
cpool_t p;
cpool_init(&p, 1, 10240);
for (int i = 1; i < 10240; i+=2) {
int v = cpool_alloc(&p);
test_assert(v >= 1 && v <= 10240);
test_assert(cpool_check(&p, v) == false);
}
cpool_free(&p, 1);
int v = cpool_alloc(&p);
test_assert(v == 1);
cpool_release(&p);
return test_success();
}
int test_verify_int(int expected_result, int test_result)
{
int return_value;
return_value = 1;
if (expected_result != test_result) {
test_failure("Comparison failure");
fprintf(stderr, " Expected result: %d\n", expected_result);
fprintf(stderr, " Test result: %d\n", test_result);
fflush(stderr);
return_value = 0;
} else {
test_success();
}
return return_value;
}
int main(int argc, const char** argv) {
unsigned long long int seed;
if (argc < 2) {
seed = (unsigned long long) std::chrono::system_clock::now().time_since_epoch().count();
} else {
seed = std::strtoull(argv[1], nullptr, 10);
}
test_failure();
test_success((uint32_t) seed, (uint32_t) 10000);
test_addition();
test_ordering();
std::cout << "TEST SUCCEEDED" << std::endl;
}
static int
test_cqueue(void)
{
test_start("cqueue");
cqueue_t q;
cqueue_init(&q, 62);
for (int k = 0; k < 100; k++) {
for (int i = 0; i < 60; i++) {
cqueue_push(&q, (cqueue_item_t) i);
}
for (int i = 0; i < 60; i++) {
int item = (int) cqueue_pop(&q);
test_assert(item == i);
}
}
cqueue_free(&q);
return test_success();
}
int
test_pd(void)
{
test_start("page directory");
seL4_CPtr p[PD_MAX];
for (int i = 0; i < PD_MAX; i++) {
p[i] = pd_assign(&procServ.PDList).kpdObject;
test_assert(p[i] != 0);
}
for (int i = 0; i < PD_MAX; i++) {
pd_free(&procServ.PDList, p[i]);
}
for (int i = 0; i < 2; i++) {
p[i] = pd_assign(&procServ.PDList).kpdObject;
test_assert(p[i] != 0);
}
for (int i = 0; i < 2; i++) {
pd_free(&procServ.PDList, p[i]);
}
return test_success();
}
static int
test_kalloc(void)
{
test_start("kalloc");
/* Test that malloc works and the process server can allocate from static heap properly. */
for (int repeats = 0; repeats < 100; repeats++) {
int *a = kmalloc(sizeof(int) * 10240);
assert(a);
for (int i = 0; i < 10240; i++) a[i] = i;
for (int i = 0; i < 10240; i++) test_assert(a[i] == i);
kfree(a);
}
/* Test that kernel obj allocation works and that the VKA allocator has been
bootstrapped properly. */
vka_object_t obj[100];
int error = -1;
for (int repeats = 0; repeats < 100; repeats++) {
for (int i = 0; i < 100; i++) {
error = vka_alloc_endpoint(&procServ.vka, &obj[i]);
test_assert(!error);
test_assert(obj[i].cptr != 0);
}
for (int i = 0; i < 100; i++) {
vka_free_object(&procServ.vka, &obj[i]);
}
for (int i = 0; i < 100; i++) {
error = vka_alloc_frame(&procServ.vka, seL4_PageBits, &obj[i]);
test_assert(!error);
test_assert(obj[i].cptr != 0);
}
for (int i = 0; i < 100; i++) {
vka_free_object(&procServ.vka, &obj[i]);
}
}
return test_success();
}
int test_verify_str(const char *expected_result, const char *test_result)
{
size_t len_expect, len_result;
int return_value;
return_value = 1;
len_expect = expected_result ? strlen(expected_result) : 0;
len_result = test_result ? strlen(test_result) : 0;
if ((!(len_expect == len_result)) ||
(0 != strcmp(expected_result, test_result))) {
test_failure("Comparison failure");
fprintf(stderr, " Expected result: %s\n", expected_result);
fprintf(stderr, " Test result: %s\n", test_result);
fflush(stderr);
return_value = 0;
} else {
test_success();
}
return return_value;
}
static int
test_file_server_connect()
{
test_start("fs connection");
/* Find the file server. */
nsv_mountpoint_t mp = nsv_resolve("fileserv/*");
test_assert(mp.success == true);
test_assert(mp.serverAnon != 0);
seL4_CPtr fileservAnon = mp.serverAnon;
const int fs_test_repeat = 5;
/* Attempt to ping the file server. */
for (int i = 0; i < fs_test_repeat; i++) {
int error = serv_ping(fileservAnon);
test_assert(error == ESUCCESS);
}
/* Repeatedly connect to and disconnect from the file server. */
for (int i = 0; i < fs_test_repeat; i++) {
int error;
seL4_CPtr fileservSession = serv_connect_direct(fileservAnon, REFOS_LIVENESS, &error);
test_assert(fileservSession && error == ESUCCESS);
if (fileservSession) {
serv_disconnect_direct(fileservSession);
seL4_CNode_Delete(REFOS_CSPACE, fileservSession, REFOS_CDEPTH);
csfree(fileservSession);
}
}
/* Release the resources stored in the valid mountpoint. */
nsv_mountpoint_release(&mp);
test_assert(mp.success == false);
test_assert(mp.serverAnon == 0);
return test_success();
}
static int
test_chash(void)
{
test_start("chash");
chash_t h;
chash_init(&h, 12);
for (int i = 0; i < 1024; i++) {
chash_set(&h, i, (chash_item_t) 0x3F1);
}
for (int i = 0; i < 1024; i++) {
int t = (int) chash_get(&h, i);
test_assert(t == 0x3F1);
}
chash_remove(&h, 123);
test_assert(chash_get(&h, 123) == NULL);
int f = chash_find_free(&h, 100, 200);
test_assert(f == 123);
for (int i = 0; i < 1024; i++) {
chash_remove(&h, i);
}
chash_release(&h);
return test_success();
}
static int
test_cvector(void)
{
test_start("cvector");
// Src: https://gist.github.com/EmilHernvall/953968
cvector_t v;
cvector_init(&v);
cvector_add(&v, (cvector_item_t)1); cvector_add(&v, (cvector_item_t)2);
cvector_add(&v, (cvector_item_t)3); cvector_add(&v, (cvector_item_t)4);
cvector_add(&v, (cvector_item_t)5);
test_assert(cvector_count(&v) == (int)5);
test_assert(cvector_get(&v, 0) == (cvector_item_t)1);
test_assert(cvector_get(&v, 1) == (cvector_item_t)2);
test_assert(cvector_get(&v, 2) == (cvector_item_t)3);
test_assert(cvector_get(&v, 3) == (cvector_item_t)4);
test_assert(cvector_get(&v, 4) == (cvector_item_t)5);
cvector_delete(&v, 1);
cvector_delete(&v, 3);
test_assert(cvector_count(&v) == (int)3);
test_assert(cvector_get(&v, 0) == (cvector_item_t)1);
test_assert(cvector_get(&v, 1) == (cvector_item_t)3);
test_assert(cvector_get(&v, 2) == (cvector_item_t)4);
cvector_free(&v);
int vcStress = 10000;
for (int i = 0; i < vcStress; i++) {
int data = ((i << 2) * 0xcafebabe) ^ 0xdeadbeef;
cvector_add(&v, (cvector_item_t)data);
test_assert(cvector_count(&v) == (int)(i + 1));
test_assert(cvector_get(&v, i) == (cvector_item_t)data);
data = (data << 7) ^ 0xbaabaabb;
cvector_set(&v, i, (cvector_item_t)data);
test_assert(cvector_count(&v) == (int)(i + 1));
test_assert(cvector_get(&v, i) == (cvector_item_t)data);
}
cvector_free(&v);
return test_success();
}
static void test(bool thread_usage){
/* local variables */
opal_pointer_array_t *array;
value_t *test_data;
int len_test_data,i,test_len_in_array,error_cnt;
int ele_index;
int use_threads,error_code;
value_t value;
/* initialize thread levels */
use_threads=(int)opal_set_using_threads(thread_usage);
array=OBJ_NEW(opal_pointer_array_t);
assert(array);
len_test_data=5;
test_data=malloc(sizeof(value_t)*len_test_data);
assert(test_data);
for(i=0 ; i < len_test_data ; i++ ) {
test_data[i].ivalue = (i+1);
}
/* add data to table */
test_len_in_array=3;
assert(len_test_data>=test_len_in_array);
for(i=0 ; i < test_len_in_array ; i++ ) {
opal_pointer_array_add(array,test_data[i].cvalue);
}
/* check to see that test_len_in_array are in array */
if( (array->size - array->number_free) == test_len_in_array) {
test_success();
} else {
test_failure("check on number of elments in array");
}
/* check order of data */
error_cnt=0;
for(i=0 ; i < test_len_in_array ; i++ ) {
value.cvalue = array->addr[i];
if( (i+1) != value.ivalue ) {
error_cnt++;
}
}
if( 0 == error_cnt ) {
test_success();
} else {
test_failure(" data check ");
}
/* free 2nd element and make sure that value is reset correctly,
* and that the lowest_index is also reset correctly */
ele_index=1;
error_code=opal_pointer_array_set_item(array,ele_index,NULL);
if( 0 == error_code ) {
test_success();
} else {
test_failure(" opal_pointer_array_set_item ");
}
if( NULL == array->addr[ele_index]){
test_success();
} else {
test_failure(" set pointer value");
}
if( ele_index == array->lowest_free ) {
test_success();
} else {
test_failure(" lowest free ");
}
/* test opal_pointer_array_get_item */
array->number_free=array->size;
array->lowest_free=0;
for(i=0 ; i < array->size ; i++ ) {
array->addr[i] = NULL;
}
error_cnt=0;
for(i=0 ; i < array->size ; i++ ) {
value.ivalue = i + 2;
ele_index=opal_pointer_array_add(array, value.cvalue);
if( i != ele_index ) {
error_cnt++;
}
}
if( 0 == error_cnt ) {
test_success();
} else {
test_failure(" opal_pointer_array_add 2nd ");
}
error_cnt=0;
for(i=0 ; i < array->size ; i++ ) {
value.cvalue = opal_pointer_array_get_item(array,i);
if( (i+2) != value.ivalue ) {
error_cnt++;
}
}
if( 0 == error_cnt ) {
test_success();
} else {
test_failure(" data check - 2nd ");
}
free (array);
free(test_data);
}
int unistd_access_test(){
//check the access to the executable
int fd;
int ret;
test_intro("access", 0, "/app/flash/posix, F_OK");
ret = access(EXEC_PATH, F_OK);
if( test_success(ret) < 0 ){ return -1; }
test_intro("access", "ENOENT", "/nomount/some/file, F_OK");
ret = access("/nomount/some/file", F_OK);
if( test_errno(ret, "ENOENT", ENOENT) < 0 ){ return -1; }
test_intro("access", "ENOENT", "/nomount, F_OK");
ret = access("/nomount", F_OK);
if( test_errno(ret, "ENOENT", ENOENT) < 0 ){ return -1; }
test_intro("access", "ENAMETOOLONG", "/0123456789012345678901234567890123456789012345678901234567890123456789, F_OK");
ret = access("/0123456789012345678901234567890123456789012345678901234567890123456789", F_OK);
if( test_errno(ret, "ENAMETOOLONG", ENAMETOOLONG) < 0 ){ return -1; }
test_intro("access", "ENAMETOOLONG", "/0123456789/01234567890/123456789/0123/4567890/123456789012345/67890123/456/789, F_OK");
ret = access("/0123456789/01234567890/123456789/0123/4567890/123456789012345/67890123/456/789", F_OK);
if( test_errno(ret, "ENAMETOOLONG", ENAMETOOLONG) < 0 ){ return -1; }
//create a file in home
test_intro("access", 0, "/home/test.txt, W_OK");
fd = open("/home/test.txt", O_RDWR | O_CREAT, 0666);
if( fd < 0 ){
return test_failed_perror();
}
if( write(fd, "test", 4) < 0 ){
close(fd);
return test_failed_perror();
}
if( close(fd) < 0 ){
return test_failed_perror();
}
ret = access("/home/test.txt", W_OK);
if( test_success(ret) < 0 ){ return -1; }
test_intro("access", "EACCESS", "app/flash/posix, W_OK");
ret = access(EXEC_PATH, W_OK);
if( test_errno(ret, "EACCES", EACCES) < 0 ){ return -1; }
test_intro("access", "EACCESS", "/, W_OK");
ret = access("/", W_OK);
if( test_errno(ret, "EACCES", EACCES) < 0 ){ return -1; }
test_intro("access", 0, "/app/flash/posix, R_OK");
ret = access(EXEC_PATH, R_OK);
if( test_success(ret) < 0 ){ return -1; }
test_intro("access", "EACCES", "/app/.install, R_OK");
ret = access("/app/.install", R_OK);
if( test_errno(ret, "EACCES", EACCES) < 0 ){ return -1; }
test_intro("access", 0, "/app/flash/posix, X_OK");
ret = access(EXEC_PATH, X_OK);
if( test_success(ret) < 0 ){ return -1; }
test_intro("access", "EACCES", "/app/.install, X_OK");
ret = access("/app/.install", X_OK);
if( test_errno(ret, "EACCES", EACCES) < 0 ){ return -1; }
return 0;
}
