自学教程：C++ test_connect函数代码示例

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;}

voidtest_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;}