int main () { int rc; int push; int pull1; int pull2; int sndprio; pull1 = test_socket (AF_SP, NN_PULL); test_bind (pull1, SOCKET_ADDRESS_A); pull2 = test_socket (AF_SP, NN_PULL); test_bind (pull2, SOCKET_ADDRESS_B); push = test_socket (AF_SP, NN_PUSH); sndprio = 1; rc = nn_setsockopt (push, NN_SOL_SOCKET, NN_SNDPRIO, &sndprio, sizeof (sndprio)); errno_assert (rc == 0); test_connect (push, SOCKET_ADDRESS_A); sndprio = 2; rc = nn_setsockopt (push, NN_SOL_SOCKET, NN_SNDPRIO, &sndprio, sizeof (sndprio)); errno_assert (rc == 0); test_connect (push, SOCKET_ADDRESS_B); test_send (push, "ABC"); test_send (push, "DEF"); test_recv (pull1, "ABC"); test_recv (pull1, "DEF"); test_close (pull1); test_close (push); test_close (pull2); /* Test removing a pipe from the list. */ push = test_socket (AF_SP, NN_PUSH); test_bind (push, SOCKET_ADDRESS_A); pull1 = test_socket (AF_SP, NN_PULL); test_connect (pull1, SOCKET_ADDRESS_A); test_send (push, "ABC"); test_recv (pull1, "ABC"); test_close (pull1); rc = nn_send (push, "ABC", 3, NN_DONTWAIT); nn_assert (rc == -1 && nn_errno() == EAGAIN); pull1 = test_socket (AF_SP, NN_PULL); test_connect (pull1, SOCKET_ADDRESS_A); test_send (push, "ABC"); test_recv (pull1, "ABC"); test_close (pull1); test_close (push); return 0; }
int main(int argc, char **argv) { char str_node_count[16]; int is_mock = 1; const char *args[] = {"--nodes", "", "--buckets=default::memcache", NULL }; if (getenv("LCB_VERBOSE_TESTS") == NULL) { FILE *unused = freopen("/dev/null", "w", stdout); (void)unused; } setup_test_timeout_handler(); total_node_count = 5; snprintf(str_node_count, 16, "%d", total_node_count); args[1] = str_node_count; setup((char **)args, "default", NULL, "default"); /* first time it's initialized */ is_mock = mock->is_mock; test_set1(); test_set2(); test_get1(); test_get2(); test_version1(); teardown(); args[2] = NULL; setup((char **)args, "default", NULL, "default"); test_set1(); test_set2(); test_get1(); test_get2(); test_touch1(); test_version1(); teardown(); if (is_mock) { lcb_assert(test_connect((char **)args, "missing", NULL, "missing") == LCB_BUCKET_ENOENT); args[2] = "--buckets=protected:secret"; lcb_assert(test_connect((char **)args, "protected", "incorrect", "protected") == LCB_AUTH_ERROR); setup((char **)args, "protected", "secret", "protected"); test_spurious_saslerr(); teardown(); } else { fprintf(stderr, "FIXME: Skipping bad auth tests in real cluster\n"); } (void)argc; (void)argv; return EXIT_SUCCESS; }
int main () { int rc; int pub1; int pub2; int sub1; int sub2; char buf [3]; pub1 = test_socket (AF_SP, NN_PUB); test_bind (pub1, SOCKET_ADDRESS); sub1 = test_socket (AF_SP, NN_SUB); rc = nn_setsockopt (sub1, NN_SUB, NN_SUB_SUBSCRIBE, "", 0); errno_assert (rc == 0); test_connect (sub1, SOCKET_ADDRESS); sub2 = test_socket (AF_SP, NN_SUB); rc = nn_setsockopt (sub2, NN_SUB, NN_SUB_SUBSCRIBE, "", 0); errno_assert (rc == 0); test_connect (sub2, SOCKET_ADDRESS); /* Wait till connections are established to prevent message loss. */ nn_sleep (10); test_send (pub1, "0123456789012345678901234567890123456789"); test_recv (sub1, "0123456789012345678901234567890123456789"); test_recv (sub2, "0123456789012345678901234567890123456789"); test_close (pub1); test_close (sub1); test_close (sub2); /* Check receiving messages from two publishers. */ sub1 = test_socket (AF_SP, NN_SUB); rc = nn_setsockopt (sub1, NN_SUB, NN_SUB_SUBSCRIBE, "", 0); errno_assert (rc == 0); test_bind (sub1, SOCKET_ADDRESS); pub1 = test_socket (AF_SP, NN_PUB); test_connect (pub1, SOCKET_ADDRESS); pub2 = test_socket (AF_SP, NN_PUB); test_connect (pub2, SOCKET_ADDRESS); nn_sleep (100); test_send (pub1, "0123456789012345678901234567890123456789"); test_send (pub2, "0123456789012345678901234567890123456789"); test_recv (sub1, "0123456789012345678901234567890123456789"); test_recv (sub1, "0123456789012345678901234567890123456789"); test_close (pub2); test_close (pub1); test_close (sub1); return 0; }
int main() { ASSERT( test_connect( "replica-set-foo" ) == MONGO_OK ); ASSERT( test_connect( "test-foobar" ) == MONGO_CONN_BAD_SET_NAME ); ASSERT( test_insert_limits( "replica-set-foo" ) == MONGO_OK ); /* ASSERT( test_reconnect( "test-rs" ) == 0 ); */ return 0; }
int main() { ASSERT( test_connect_deprecated( REPLICA_SET_NAME ) == MONGO_OK ); ASSERT( test_connect( REPLICA_SET_NAME ) == MONGO_OK ); ASSERT( test_connect( "test-foobar" ) == MONGO_CONN_BAD_SET_NAME ); ASSERT( test_insert_limits( REPLICA_SET_NAME ) == MONGO_OK ); /* ASSERT( test_reconnect( "test-rs" ) == 0 ); */ return 0; }
int main () { int push1; int push2; int pull1; int pull2; /* Test fan-out. */ push1 = test_socket (AF_SP, NN_PUSH); test_bind (push1, SOCKET_ADDRESS); pull1 = test_socket (AF_SP, NN_PULL); test_connect (pull1, SOCKET_ADDRESS); pull2 = test_socket (AF_SP, NN_PULL); test_connect (pull2, SOCKET_ADDRESS); /* Wait till both connections are established to get messages spread evenly between the two pull sockets. */ nn_sleep (10); test_send (push1, "ABC"); test_send (push1, "DEF"); test_recv (pull1, "ABC"); test_recv (pull2, "DEF"); test_close (push1); test_close (pull1); test_close (pull2); /* Test fan-in. */ pull1 = test_socket (AF_SP, NN_PULL); test_bind (pull1, SOCKET_ADDRESS); push1 = test_socket (AF_SP, NN_PUSH); test_connect (push1, SOCKET_ADDRESS); push2 = test_socket (AF_SP, NN_PUSH); test_connect (push2, SOCKET_ADDRESS); test_send (push1, "ABC"); test_send (push2, "DEF"); test_recv (pull1, "ABC"); test_recv (pull1, "DEF"); test_close (pull1); test_close (push1); test_close (push2); return 0; }
int main(int argc, char **argv) { int rc; HSTMT hstmt = SQL_NULL_HSTMT; char sql[100000]; char *sqlend; int i; test_connect(); rc = SQLAllocStmt(conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } rc = SQLTables(hstmt, "", SQL_NTS, "public", SQL_NTS, "%", SQL_NTS, "TABLE", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLTables failed", hstmt); print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* Clean up */ test_disconnect(); }
int main(int argc, char **argv) { grpc_test_init(argc, argv); grpc_iomgr_init(); grpc_pollset_init(&g_pollset); test_no_op(); test_no_op_with_start(); test_no_op_with_port(); test_no_op_with_port_and_start(); test_connect(1); test_connect(10); grpc_pollset_shutdown(&g_pollset, destroy_pollset, &g_pollset); grpc_iomgr_shutdown(); return 0; }
int main(int argc, char *argv[]) { char addr[128] = "127.0.0.1:8283"; int ch; acl_init(); test(); while ((ch = getopt(argc, argv, "hs:")) > 0) { switch (ch) { case 'h': usage(argv[0]); return (0); case 's': ACL_SAFE_STRNCPY(addr, optarg, sizeof(addr)); break; default: break; } } test_connect(addr); return (0); }
int main( int argc, char *argv[] ){ int sock; config_t *conf; if ( argc > 1 ) conf = parse_file( argv[1] ); else conf = parse_file( PREFIX"/etc/client.conf" ); if ( conf ) printf( "Read client config.\n" ); else die( 1, "Could not open client config\n" ); sock = connect_to_serv( conf ); if ( sock < 0 ) die( 1, "Unknown socket error" ); test_connect( sock ); close( sock ); free( conf ); return 0; }
int main (int argc, const char *argv[]) { int end0; int end1; struct nn_thread thread5; struct nn_thread thread6; int port = get_test_port(argc, argv); test_addr_from(socket_address_h, "tcp", "127.0.0.1", port); test_addr_from(socket_address_i, "tcp", "127.0.0.1", port + 1); test_addr_from(socket_address_j, "tcp", "127.0.0.1", port + 2); /* Test the bi-directional device with REQ/REP (headers). */ /* Start the devices. */ nn_thread_init (&thread5, device5, NULL); nn_thread_init (&thread6, device6, NULL); /* Create two sockets to connect to the device. */ end0 = test_socket (AF_SP, NN_REQ); test_connect (end0, socket_address_h); end1 = test_socket (AF_SP, NN_REP); test_connect (end1, socket_address_j); /* Wait for TCP to establish. */ nn_sleep (100); /* Pass a message between endpoints. */ test_send (end0, "XYZ"); test_recv (end1, "XYZ"); /* Now send a reply. */ test_send (end1, "REPLYXYZ"); test_recv (end0, "REPLYXYZ"); /* Clean up. */ test_close (end0); test_close (end1); /* Shut down the devices. */ nn_term (); nn_thread_term (&thread5); nn_thread_term (&thread6); return 0; }
int main(int argc, char **argv) { grpc_test_init(argc, argv); grpc_iomgr_init(); gpr_mu_init(&mu); gpr_cv_init(&cv); test_no_op(); test_no_op_with_start(); test_no_op_with_port(); test_no_op_with_port_and_start(); test_connect(1); test_connect(10); grpc_iomgr_shutdown(); gpr_mu_destroy(&mu); gpr_cv_destroy(&cv); return 0; }
static void test_chnlat(void) { if (g_test_trap_fork(60 * 1000 * 1000, 0) == TRUE) { test_connect(FALSE); exit(0); } g_test_trap_assert_passed(); //g_test_trap_assert_stderr("failed"); }
int main (NN_UNUSED int argc, const NN_UNUSED char *argv[]) { int sb; int sc1; int sc2; sb = test_socket (AF_SP, NN_PAIR); test_bind (sb, "inproc://pair"); sc1 = test_socket (AF_SP, NN_PAIR); test_connect (sc1, "inproc://pair"); sc2 = test_socket (AF_SP, NN_PAIR); test_connect (sc2, "inproc://pair"); test_send (sb, "HELLO"); test_recv (sc1, "HELLO"); test_send (sc1, "THERE"); test_recv (sb, "THERE"); return 0; }
static void routine (NN_UNUSED void *arg) { int s; s = nn_socket (AF_SP, NN_SUB); if (s < 0 && nn_errno () == EMFILE) return; errno_assert (s >= 0); test_connect (s, SOCKET_ADDRESS); test_close (s); }
int main () { int end0; int end1; struct nn_thread thread5; struct nn_thread thread6; /* Test the bi-directional device with REQ/REP (headers). */ /* Start the devices. */ nn_thread_init (&thread5, device5, NULL); nn_thread_init (&thread6, device6, NULL); /* Create two sockets to connect to the device. */ end0 = test_socket (AF_SP, NN_REQ); test_connect (end0, SOCKET_ADDRESS_H); end1 = test_socket (AF_SP, NN_REP); test_connect (end1, SOCKET_ADDRESS_J); /* Wait for TCP to establish. */ nn_sleep (1000); /* Pass a message between endpoints. */ test_send (end0, "XYZ"); test_recv (end1, "XYZ"); /* Now send a reply. */ test_send (end1, "REPLYXYZ"); test_recv (end0, "REPLYXYZ"); /* Clean up. */ test_close (end0); test_close (end1); /* Shut down the devices. */ nn_term (); nn_thread_term (&thread5); nn_thread_term (&thread6); return 0; }
int main(int argc, char **argv) { grpc_closure destroyed; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_test_init(argc, argv); grpc_init(); g_pollset = gpr_malloc(grpc_pollset_size()); grpc_pollset_init(g_pollset, &g_mu); test_no_op(); test_no_op_with_start(); test_no_op_with_port(); test_no_op_with_port_and_start(); test_connect(1); test_connect(10); grpc_closure_init(&destroyed, destroy_pollset, g_pollset); grpc_pollset_shutdown(&exec_ctx, g_pollset, &destroyed); grpc_exec_ctx_finish(&exec_ctx); grpc_shutdown(); gpr_free(g_pollset); return 0; }
int main(int argc, char **argv) { int rc; HSTMT hstmt = SQL_NULL_HSTMT; test_connect(); rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } /* * Execute an erroneous query, and call SQLGetDiagRec twice on the * statement. Should get the same result both times; SQLGetDiagRec is * not supposed to change the state of the statement. */ rc = SQLExecDirect(hstmt, (SQLCHAR *) "broken query ", SQL_NTS); print_diag("SQLExecDirect", SQL_HANDLE_STMT, hstmt); print_diag("get same message again", SQL_HANDLE_STMT, hstmt); rc = SQLEndTran(SQL_HANDLE_DBC, conn, SQL_ROLLBACK); CHECK_STMT_RESULT(rc, "SQLEndTran failed", hstmt); rc = SQLFreeStmt(hstmt, SQL_DROP); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* kill this connection */ printf ("killing connection...\n"); rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } rc = SQLExecDirect(hstmt, (SQLCHAR *) "select pg_terminate_backend(pg_backend_pid()) ", SQL_NTS); print_diag(NULL, SQL_HANDLE_STMT, hstmt); /* * Test SQLGetDiagRec on the connection, after the backend connection is * dead. Twice, again to check that the first call doesn't clear the * error. */ print_diag("SQLGetDiagRec on connection says:", SQL_HANDLE_DBC, conn); print_diag("SQLGetDiagRec called again:", SQL_HANDLE_DBC, conn); return 0; }
int main(int argc, char *argv[]) { printf("Userlevel Firewall Test Application!\n"); printf("bind to port 1234: "); if (test_bind(1234) < 0) { printf("failed!\n"); perror("cause"); return 1; } printf("succeeded\n"); printf("bind to port 4321 (expect failure): "); if (test_bind(4321) == 0) { printf("succeeded!\n"); return 1; } printf("failed\n"); printf("connect to www.scs.stanford.edu(171.66.3.9):80: "); if (test_connect("171.66.3.9", 80) < 0) { printf("failed!\n"); perror("cause"); return 1; } printf("succeeded\n"); printf("connect to market.scs.stanford.edu(171.66.3.10):22: "); if (test_connect("171.66.3.10", 22) == 0) { printf("succeeded!\n"); return 1; } printf("failed\n"); printf("all tests passed!\n"); return 0; }
int testshutdown() { int s; int rc; int eid; printf("test shutdown\n"); /* Run endpoint shutdown and socket shutdown in parallel. */ s = test_socket (AF_SP, NN_REQ); eid = test_connect (s, "tcp://127.0.0.1:5590"); rc = nn_shutdown (s, eid); errno_assert (rc == 0); test_close (s); return 0; }
int main(int argc, char **argv) { SQLRETURN rc; HSTMT hstmt = SQL_NULL_HSTMT; test_connect(); rc = SQLAllocStmt(conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } /* Create a table to test with */ rc = SQLExecDirect(hstmt, (SQLCHAR *) "CREATE TEMPORARY TABLE testtbl(t varchar(40))", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); /**** A simple query against the table, fetch column info ****/ rc = SQLExecDirect(hstmt, "SELECT * FROM testtbl", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); /* Get column metadata */ print_result_meta(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* Alter the table */ rc = SQLExecDirect(hstmt, (SQLCHAR *) "ALTER TABLE testtbl ALTER COLUMN t TYPE varchar(80)", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); /* Run the query again, check if the metadata was updated */ rc = SQLExecDirect(hstmt, "SELECT * FROM testtbl", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); /* Get column metadata */ print_result_meta(hstmt); /* Clean up */ test_disconnect(); return 0; }
void execute_line(char *cmdbuf) { int argc; char *argv[MAXARGS]; argc = parse(cmdbuf, argv); if (argc == 0) return; if (!strcmp(argv[0], "noop")) test_noop(); else if (!strcmp(argv[0], "connect") || !strcmp(argv[0], "c")) test_connect(argc, argv); else if (!strcmp(argv[0], "disconnect") || !strcmp(argv[0], "d")) test_disconnect(); else if (!strcmp(argv[0], "host")) test_host(); else if (!strcmp(argv[0], "motd") || !strcmp(argv[0], "m")) test_motd(); else if (!strcmp(argv[0], "query") || !strcmp(argv[0], "qy")) test_query(argc, argv); else if (!strcmp(argv[0], "auth") || !strcmp(argv[0], "a")) test_krb5_auth(); else if (!strcmp(argv[0], "proxy") || !strcmp(argv[0], "p")) test_proxy(argc, argv); else if (!strcmp(argv[0], "access")) test_access(argc, argv); else if (!strcmp(argv[0], "dcm")) test_dcm(); else if (!strcmp(argv[0], "script") || !strcmp(argv[0], "s")) test_script(argc, argv); else if (!strcmp(argv[0], "list_requests") || !strcmp(argv[0], "lr") || !strcmp(argv[0], "?")) test_list_requests(); else if (!strcmp(argv[0], "quit") || !strcmp(argv[0], "Q")) quit = 1; else if (!strcmp(argv[0], "version") || !strcmp(argv[0], "v")) test_version(argc, argv); else if (!strcmp(argv[0], "krb4_auth") || !strcmp(argv[0], "4")) test_auth(); else { fprintf(stderr, "moira: Unknown request \"%s\". " "Type \"?\" for a request list.\n", argv[0]); } }
static void routine2 (NN_UNUSED void *arg) { int s; int i; s = test_socket (AF_SP, NN_PULL); for (i = 0; i < 10; ++i) { test_connect (s, SOCKET_ADDRESS); } for (i = 0; i < MESSAGES_PER_THREAD; ++i) { test_recv (s, "hello"); } test_close (s); nn_atomic_dec(&active, 1); }
static void routine2 (NN_UNUSED void *arg) { int s; int i; s = test_socket (AF_SP, NN_PULL); for (i = 0; i < 10; ++i) { test_connect (s, SOCKET_ADDRESS); } for (i = 0; i < MESSAGES_PER_THREAD; ++i) { test_recv (s, "hello"); } //printf("inactivate socket active.%d\n",active); test_close (s); active --; }
static void routine2 (NN_UNUSED void *arg) { int s; int i; s = test_socket (AF_SP, NN_PULL); for (i = 0; i < 10; ++i) { test_connect (s, SOCKET_ADDRESS); } for (i = 0; i < 10; ++i) { test_recv (s, "hello"); } test_close (s); active --; }
void device6 (NN_UNUSED void *arg) { int rc; int dev2; int dev3; dev2 = test_socket (AF_SP_RAW, NN_REP); test_connect (dev2, socket_address_i); dev3 = test_socket (AF_SP_RAW, NN_REQ); test_bind (dev3, socket_address_j); /* Run the device. */ rc = nn_device (dev2, dev3); nn_assert (rc < 0 && nn_errno () == ETERM); /* Clean up. */ test_close (dev2); test_close (dev3); }
int main (int argc, const char *argv[]) { int s; int rc; int eid; char socket_address[128]; test_addr_from(socket_address, "tcp", "127.0.0.1", get_test_port(argc, argv)); /* Run endpoint shutdown and socket shutdown in parallel. */ s = test_socket (AF_SP, NN_REQ); eid = test_connect (s, socket_address); rc = nn_shutdown (s, eid); errno_assert (rc == 0); test_close (s); return 0; }
void test_quit_after_connect (void) { const gchar *packet; gsize packet_size; test_connect(); channel_free(); reply_continue(); cut_assert_true(milter_server_context_quit(context)); pump_all_events(); milter_test_assert_state(QUIT); milter_test_assert_status(NOT_CHANGE); milter_command_encoder_encode_quit(encoder, &packet, &packet_size); milter_test_assert_packet(channel, packet, packet_size); }
int main(int argc, char **argv) { int rc; HSTMT hstmt = SQL_NULL_HSTMT; char sql[100000]; char *sqlend; int i; char *strings[] = { "param'quote", "param\\backslash", "ends with backslash\\", NULL }; test_connect(); rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } rc = SQLExecDirect(hstmt, (SQLCHAR *) "SET standard_conforming_strings=on", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); for (i = 0; strings[i] != NULL; i++) execWithParam(hstmt, strings[i]); rc = SQLExecDirect(hstmt, (SQLCHAR *) "SET standard_conforming_strings=off", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); for (i = 0; strings[i] != NULL; i++) execWithParam(hstmt, strings[i]); /* Clean up */ test_disconnect(); }
int main () { int rc; int sb; int sc; struct nn_iovec iov [2]; struct nn_msghdr hdr; char buf [6]; sb = test_socket (AF_SP, NN_PAIR); test_bind (sb, SOCKET_ADDRESS); sc = test_socket (AF_SP, NN_PAIR); test_connect (sc, SOCKET_ADDRESS); iov [0].iov_base = "AB"; iov [0].iov_len = 2; iov [1].iov_base = "CDEF"; iov [1].iov_len = 4; memset (&hdr, 0, sizeof (hdr)); hdr.msg_iov = iov; hdr.msg_iovlen = 2; rc = nn_sendmsg (sc, &hdr, 0); errno_assert (rc >= 0); nn_assert (rc == 6); iov [0].iov_base = buf; iov [0].iov_len = 4; iov [1].iov_base = buf + 4; iov [1].iov_len = 2; memset (&hdr, 0, sizeof (hdr)); hdr.msg_iov = iov; hdr.msg_iovlen = 2; rc = nn_recvmsg (sb, &hdr, 0); errno_assert (rc >= 0); nn_assert (rc == 6); nn_assert (memcmp (buf, "ABCDEF", 6) == 0); test_close (sc); test_close (sb); return 0; }