void test_spiffs_overwrite_append(const char* filename) { /* Create new file with 'aaaa' */ test_spiffs_create_file_with_text(filename, "aaaa"); /* Append 'bbbb' to file */ FILE *f_a = fopen(filename, "a"); TEST_ASSERT_NOT_NULL(f_a); TEST_ASSERT_NOT_EQUAL(EOF, fputs("bbbb", f_a)); TEST_ASSERT_EQUAL(0, fclose(f_a)); /* Read back 8 bytes from file, verify it's 'aaaabbbb' */ char buf[10] = { 0 }; FILE *f_r = fopen(filename, "r"); TEST_ASSERT_NOT_NULL(f_r); TEST_ASSERT_EQUAL(8, fread(buf, 1, 8, f_r)); TEST_ASSERT_EQUAL_STRING_LEN("aaaabbbb", buf, 8); /* Be sure we're at end of file */ TEST_ASSERT_EQUAL(0, fread(buf, 1, 8, f_r)); TEST_ASSERT_EQUAL(0, fclose(f_r)); /* Overwrite file with 'cccc' */ test_spiffs_create_file_with_text(filename, "cccc"); /* Verify file now only contains 'cccc' */ f_r = fopen(filename, "r"); TEST_ASSERT_NOT_NULL(f_r); bzero(buf, sizeof(buf)); TEST_ASSERT_EQUAL(4, fread(buf, 1, 8, f_r)); // trying to read 8 bytes, only expecting 4 TEST_ASSERT_EQUAL_STRING_LEN("cccc", buf, 4); TEST_ASSERT_EQUAL(0, fclose(f_r)); }
TEST(shell, start) { char test_chars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', '\n', 0 }; char *p = test_chars; s_handle = shell_create(s_pool, POOL_SIZE, stub_putc, stub_getc, stub_exec, NULL); TEST_ASSERT_NOT_NULL( s_handle ); TEST_ASSERT_UNLESS( shell_set_prompt(s_handle, "") ); pthread_create(&s_thread, NULL, thread_shell, NULL); while (*p) { while (s_txc); s_txc = *p++; } pthread_mutex_lock(&s_mutex); pthread_cond_wait(&s_cv, &s_mutex); pthread_mutex_unlock(&s_mutex); TEST_ASSERT_EQUAL_STRING_LEN(test_chars, s_rxbuf, strlen(test_chars)); /* excludes new line code */ TEST_ASSERT_EQUAL_STRING_LEN(test_chars, s_result_line, strlen(test_chars) - 1); TEST_ASSERT_UNLESS( shell_destroy(s_handle) ); s_txc = '\n'; pthread_join(s_thread, NULL); }
void test_router_2_router (bool named_) { char buff[256]; const char msg[] = "hi 1"; const int zero = 0; char my_endpoint[MAX_SOCKET_STRING]; // Create bind socket. void *rbind = test_context_socket (ZMQ_ROUTER); TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (rbind, ZMQ_LINGER, &zero, sizeof (zero))); bind_loopback_ipv4 (rbind, my_endpoint, sizeof my_endpoint); // Create connection socket. void *rconn1 = test_context_socket (ZMQ_ROUTER); TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (rconn1, ZMQ_LINGER, &zero, sizeof (zero))); // If we're in named mode, set some identities. if (named_) { TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (rbind, ZMQ_ROUTING_ID, x_routing_id, 1)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_setsockopt (rconn1, ZMQ_ROUTING_ID, y_routing_id, 1)); } // Make call to connect using a connect_routing_id. TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (rconn1, ZMQ_CONNECT_ROUTING_ID, rconn1routing_id, strlen (rconn1routing_id))); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rconn1, my_endpoint)); /* Uncomment to test assert on duplicate routing id // Test duplicate connect attempt. TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (rconn1, ZMQ_CONNECT_ROUTING_ID, rconn1routing_id, strlen (rconn1routing_id))); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rconn1, bindip)); */ // Send some data. send_string_expect_success (rconn1, rconn1routing_id, ZMQ_SNDMORE); send_string_expect_success (rconn1, msg, 0); // Receive the name. const int routing_id_len = zmq_recv (rbind, buff, 256, 0); if (named_) { TEST_ASSERT_EQUAL_INT (strlen (y_routing_id), routing_id_len); TEST_ASSERT_EQUAL_STRING_LEN (y_routing_id, buff, routing_id_len); } else { TEST_ASSERT_TRUE (routing_id_len && 0 == buff[0]); } // Receive the data. recv_string_expect_success (rbind, msg, 0); // Send some data back. const int ret = zmq_send (rbind, buff, routing_id_len, ZMQ_SNDMORE); TEST_ASSERT_EQUAL_INT (routing_id_len, ret); send_string_expect_success (rbind, "ok", 0); // If bound socket identity naming a problem, we'll likely see something funky here. recv_string_expect_success (rconn1, rconn1routing_id, 0); recv_string_expect_success (rconn1, "ok", 0); TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (rbind, my_endpoint)); test_context_socket_close (rbind); test_context_socket_close (rconn1); }
void test_stream_disconnect () { size_t len = MAX_SOCKET_STRING; char bind_endpoint[MAX_SOCKET_STRING]; char connect_endpoint[MAX_SOCKET_STRING]; void *sockets[2]; sockets[SERVER] = test_context_socket (ZMQ_STREAM); int enabled = 1; TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt ( sockets[SERVER], ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sockets[SERVER], "tcp://0.0.0.0:*")); TEST_ASSERT_SUCCESS_ERRNO ( zmq_getsockopt (sockets[SERVER], ZMQ_LAST_ENDPOINT, bind_endpoint, &len)); // Apparently Windows can't connect to 0.0.0.0. A better fix would be welcome. #ifdef ZMQ_HAVE_WINDOWS sprintf (connect_endpoint, "tcp://127.0.0.1:%s", strrchr (bind_endpoint, ':') + 1); #else strcpy (connect_endpoint, bind_endpoint); #endif sockets[CLIENT] = test_context_socket (ZMQ_STREAM); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt ( sockets[CLIENT], ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled))); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sockets[CLIENT], connect_endpoint)); // wait for connect notification // Server: Grab the 1st frame (peer routing id). zmq_msg_t peer_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&peer_frame, sockets[SERVER], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[SERVER])); // Server: Grab the 2nd frame (actual payload). zmq_msg_t data_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&data_frame, sockets[SERVER], 0)); TEST_ASSERT_EQUAL_INT (0, zmq_msg_size (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); // Client: Grab the 1st frame (peer routing id). TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&peer_frame, sockets[CLIENT], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[CLIENT])); // Client: Grab the 2nd frame (actual payload). TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&data_frame, sockets[CLIENT], 0)); TEST_ASSERT_EQUAL_INT (0, zmq_msg_size (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); // Send initial message. char blob_data[256]; size_t blob_size = sizeof (blob_data); TEST_ASSERT_SUCCESS_ERRNO ( zmq_getsockopt (sockets[CLIENT], ZMQ_ROUTING_ID, blob_data, &blob_size)); TEST_ASSERT_GREATER_THAN (0, blob_size); zmq_msg_t msg; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init_size (&msg, blob_size)); memcpy (zmq_msg_data (&msg), blob_data, blob_size); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&msg, sockets[dialog[0].turn], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&msg)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_init_size (&msg, strlen (dialog[0].text))); memcpy (zmq_msg_data (&msg), dialog[0].text, strlen (dialog[0].text)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&msg, sockets[dialog[0].turn], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&msg)); // TODO: make sure this loop doesn't loop forever if something is wrong // with the test (or the implementation). int step = 0; while (step < steps) { // Wait until something happens. zmq_pollitem_t items[] = { {sockets[SERVER], 0, ZMQ_POLLIN, 0}, {sockets[CLIENT], 0, ZMQ_POLLIN, 0}, }; TEST_ASSERT_SUCCESS_ERRNO (zmq_poll (items, 2, 100)); // Check for data received by the server. if (items[SERVER].revents & ZMQ_POLLIN) { TEST_ASSERT_EQUAL_INT (CLIENT, dialog[step].turn); // Grab the 1st frame (peer routing id). zmq_msg_t peer_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&peer_frame, sockets[SERVER], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[SERVER])); // Grab the 2nd frame (actual payload). zmq_msg_t data_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&data_frame, sockets[SERVER], 0)); // Make sure payload matches what we expect. const char *const data = (const char *) zmq_msg_data (&data_frame); const size_t size = zmq_msg_size (&data_frame); // 0-length frame is a disconnection notification. The server // should receive it as the last step in the dialogue. if (size == 0) { ++step; TEST_ASSERT_EQUAL_INT (steps, step); } else { TEST_ASSERT_EQUAL_INT (strlen (dialog[step].text), size); TEST_ASSERT_EQUAL_STRING_LEN (dialog[step].text, data, size); ++step; TEST_ASSERT_LESS_THAN_INT (steps, step); // Prepare the response. TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_init_size (&data_frame, strlen (dialog[step].text))); memcpy (zmq_msg_data (&data_frame), dialog[step].text, zmq_msg_size (&data_frame)); // Send the response. TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&peer_frame, sockets[SERVER], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&data_frame, sockets[SERVER], ZMQ_SNDMORE)); } // Release resources. TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); } // Check for data received by the client. if (items[CLIENT].revents & ZMQ_POLLIN) { TEST_ASSERT_EQUAL_INT (SERVER, dialog[step].turn); // Grab the 1st frame (peer routing id). zmq_msg_t peer_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&peer_frame, sockets[CLIENT], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&peer_frame)); TEST_ASSERT_TRUE (has_more (sockets[CLIENT])); // Grab the 2nd frame (actual payload). zmq_msg_t data_frame; TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_recv (&data_frame, sockets[CLIENT], 0)); TEST_ASSERT_GREATER_THAN_INT (0, zmq_msg_size (&data_frame)); // Make sure payload matches what we expect. const char *const data = (const char *) zmq_msg_data (&data_frame); const size_t size = zmq_msg_size (&data_frame); TEST_ASSERT_EQUAL_INT (strlen (dialog[step].text), size); TEST_ASSERT_EQUAL_STRING_LEN (dialog[step].text, data, size); ++step; // Prepare the response (next line in the dialog). TEST_ASSERT_LESS_THAN_INT (steps, step); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_init_size (&data_frame, strlen (dialog[step].text))); memcpy (zmq_msg_data (&data_frame), dialog[step].text, zmq_msg_size (&data_frame)); // Send the response. TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&peer_frame, sockets[CLIENT], ZMQ_SNDMORE)); TEST_ASSERT_SUCCESS_ERRNO ( zmq_msg_send (&data_frame, sockets[CLIENT], ZMQ_SNDMORE)); // Release resources. TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&peer_frame)); TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_close (&data_frame)); } } TEST_ASSERT_EQUAL_INT (steps, step); test_context_socket_close (sockets[CLIENT]); test_context_socket_close (sockets[SERVER]); }