void test_strings(void)
{
int i;
char str[512];
struct rb_node *node;
struct rb_tree *tree = rb_create(string_cmp,
string_free, string_free,
string_print, string_print);
assert( rb_isempty(tree) == 1 );
srand(4545);
for (i = 0; i < 10000; i++)
{
snprintf(str, sizeof(str), "test%d", rand() % 1000000);
rb_insert(tree, strdup(str), strdup("value"));
}
srand(4545);
for (i = 0; i < 10000; i++)
{
snprintf(str, sizeof(str), "test%d", rand() % 1000000);
node = rb_find(tree, str);
assert(node);
}
{
node = rb_find(tree, "test46554A");
assert(node == NULL);
}
assert( rb_isempty(tree) == 0 );
assert( rb_size(tree) == 10000 );
srand(4545);
for (i = 0; i < 10000; i++)
{
snprintf(str, sizeof(str), "test%d", rand() % 1000000);
node = rb_find(tree, str);
assert(node);
rb_delete(tree, node);
}
assert( rb_isempty(tree) == 1 );
assert( rb_size(tree) == 0 );
rb_destroy(tree);
}
void test_integers(void)
{
int i;
intptr_t val;
struct rb_node *node;
struct rb_tree *tree = rb_create(integer_cmp,
integer_free, integer_free,
integer_print, integer_print);
assert( rb_isempty(tree) == 1 );
srand(4545);
for (i = 0; i < 10000; i++)
{
val = rand() % 1000000;
rb_insert(tree, (void*)val, (void*)val);
}
srand(4545);
for (i = 0; i < 10000; i++)
{
val = rand() % 1000000;
node = rb_find(tree, (void*)val);
assert(node);
}
{
node = rb_find(tree, (void*)234324);
assert(node == NULL);
}
assert( rb_isempty(tree) == 0 );
assert( rb_size(tree) == 10000 );
srand(4545);
for (i = 0; i < 10000; i++)
{
val = rand() % 1000000;
node = rb_find(tree, (void*)val);
assert(node);
rb_delete(tree, node);
}
assert( rb_isempty(tree) == 1 );
assert( rb_size(tree) == 0 );
rb_destroy(tree);
}
void test_integers_multi(int factor)
{
int i;
intptr_t val;
unsigned int count;
struct rb_node *node;
struct rb_tree *tree = rb_create(integer_cmp,
integer_free, integer_free,
integer_print, integer_print);
assert( rb_isempty(tree) == 1 );
for (i = 0; i < 100 * factor; i++)
{
val = i % factor;
rb_insert(tree, (void*)val, (void*)val);
}
assert( rb_isempty(tree) == 0 );
assert( rb_size(tree) == (unsigned int)100 * factor);
for (i = 0; i < factor; i++)
{
val = i;
node = rb_find(tree, (void*)val);
assert(node);
count = 0;
while (node != rb_end(tree) && (intptr_t)node->key == i)
{
++count;
node = rb_successor(tree, node);
}
assert(count == 100);
}
{
count = 0;
for(node = rb_begin(tree); node != rb_end(tree);
node = rb_successor(tree, node))
{
assert((intptr_t)node->key == (count++ / 100));
}
}
for (i = 0; i < 100 * factor; i++)
{
val = i % factor;
node = rb_find(tree, (void*)val);
assert(node);
rb_delete(tree, node);
}
assert( rb_isempty(tree) == 1 );
rb_destroy(tree);
}
int main(int argc, char *argv[])
{
pid_t child_pid;
int child_exit_status;
struct termios tty_attr;
struct winsize window_size;
int pty_master;
/* for select */
fd_set readfds;
fd_set writefds;
unsigned err_n_rpty = 0;
unsigned err_n_wpty = 0;
unsigned err_n_stdin = 0;
unsigned err_n_stdout = 0;
int done = 0;
/* the ring buffers */
char inbuf_mem[BUFSIZE];
char outbuf_mem[BUFSIZE];
struct ring_buffer inbuf;
struct ring_buffer outbuf;
rb_init(&inbuf, inbuf_mem, sizeof(inbuf_mem));
rb_init(&outbuf, outbuf_mem, sizeof(outbuf_mem));
if (argc == 1) {
printf("usage: %s PROGRAM [ARGS]...\n", argv[0]);
exit(1);
}
/* We need I/O calls to fail with EINTR on SIGCHLD... */
if (signal(SIGCHLD, sigchld_handler) == SIG_ERR) {
perror("signal(SIGCHLD,...)");
exit(EX_OSERR);
}
if (isatty(STDIN_FILENO)) {
/* get terminal parameters associated with stdout */
if (tcgetattr(STDOUT_FILENO, &tty_attr) < 0) {
perror("tcgetattr(stdout,...)");
exit(EX_OSERR);
}
/* get window size */
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &window_size) < 0) {
perror("ioctl(stdout,...)");
exit(1);
}
child_pid = forkpty(&pty_master, NULL, &tty_attr, &window_size);
} else { /* not interactive */
child_pid = forkpty(&pty_master, NULL, NULL, NULL);
}
if (child_pid < 0) {
perror("forkpty()");
exit(EX_OSERR);
}
if (child_pid == 0) { /* in the child */
struct termios s_tty_attr;
if (tcgetattr(STDIN_FILENO, &s_tty_attr)) {
perror("tcgetattr(stdin,...)");
exit(EXIT_FAILURE);
}
/* Turn off echo */
s_tty_attr.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
/* Also turn of NL to CR?LF on output */
s_tty_attr.c_oflag &= ~(ONLCR);
if (tcsetattr(STDIN_FILENO, TCSANOW, &s_tty_attr)) {
perror("tcsetattr(stdin,...)");
exit(EXIT_FAILURE);
}
if (execvp(argv[1], argv + 1)) {
perror("execvp()");
exit(EXIT_FAILURE);
}
}
/* Non blocking mode for all file descriptors. */
setfd_nonblock(pty_master);
setfd_nonblock(STDIN_FILENO);
setfd_nonblock(STDOUT_FILENO);
if (isatty(STDIN_FILENO)) {
if (tty_semi_raw(STDIN_FILENO) < 0) {
perror("tty_semi_raw(stdin)");
}
if (atexit(tty_atexit) < 0) {
perror("atexit()");
}
}
do {
/* Accept events only on fds, that we can handle now. */
int do_select = 0;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
if (rb_space(&outbuf) > 0 && err_n_rpty < MAXRETR) {
FD_SET(pty_master, &readfds);
do_select = 1;
}
if (!rb_isempty(&inbuf) && err_n_wpty < MAXRETR) {
FD_SET(pty_master, &writefds);
do_select = 1;
}
if (rb_space(&inbuf) > 0 && err_n_stdin < MAXRETR) {
FD_SET(STDIN_FILENO, &readfds);
do_select = 1;
}
if (!rb_isempty(&outbuf) && err_n_stdout < MAXRETR) {
FD_SET(STDOUT_FILENO, &writefds);
do_select = 1;
}
if (!do_select) {
#ifdef DEBUG
fprintf(stderr, "No I/O job for us, calling waitpid()...\n");
#endif
while (waitpid(child_pid, &child_exit_status, 0) < 0)
{
/* nothing */
}
break;
}
errno = 0;
int select_rc = select(pty_master + 1, &readfds, &writefds, NULL, NULL);
if (select_rc < 0 && errno != EINTR) {
perror("select()");
exit(EX_IOERR);
}
#ifdef DEBUG
fprintf(stderr, "select() returned %d\n", select_rc);
#endif
if (FD_ISSET(STDOUT_FILENO, &writefds)) {
#ifdef DEBUG
fprintf(stderr, "stdout can be written\n");
#endif
ssize_t n = rb_write(&outbuf, STDOUT_FILENO);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_stdout++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes written into stdout\n", n);
else
perror("write(stdout,...)");
#endif
}
if (FD_ISSET(pty_master, &writefds)) {
#ifdef DEBUG
fprintf(stderr, "pty_master can be written\n");
#endif
ssize_t n = rb_write(&inbuf, pty_master);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_wpty++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes written into pty_master\n", n);
else
perror("write(pty_master,...)");
#endif
}
if (FD_ISSET(STDIN_FILENO, &readfds)) {
#ifdef DEBUG
fprintf(stderr, "stdin can be read\n");
#endif
ssize_t n = rb_read(&inbuf, STDIN_FILENO);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_stdin++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes read from stdin\n", n);
else
perror("read(stdin,...)");
#endif
}
if (FD_ISSET(pty_master, &readfds)) {
#ifdef DEBUG
fprintf(stderr, "pty_master can be read\n");
#endif
ssize_t n = rb_read(&outbuf, pty_master);
if (n <= 0 && n != EINTR && n != EAGAIN)
err_n_rpty++;
#ifdef DEBUG
if (n >= 0)
fprintf(stderr, "%d bytes read from pty_master\n", n);
else
perror("read(pty_master,...)");
#endif
}
if (!done && waitpid(child_pid, &child_exit_status, WNOHANG) > 0)
done = 1;
} while (!done
|| !(rb_isempty(&inbuf) || err_n_wpty >= MAXRETR)
|| !(rb_isempty(&outbuf) || err_n_stdout >= MAXRETR));
#ifdef DEBUG
fprintf(stderr, "inbuf: %u bytes left, outbuf: %u bytes left\n", inbuf.count, outbuf.count);
fprintf(stderr, "err_n_rpty=%u, err_n_wpty=%u, err_n_stdin=%u, err_n_stdout=%u\n",
err_n_rpty, err_n_wpty, err_n_stdin, err_n_stdout);
#endif
if (WIFEXITED(child_exit_status))
exit(WEXITSTATUS(child_exit_status));
else if (WIFSIGNALED(child_exit_status))
exit(128 + WTERMSIG(child_exit_status));
exit(EXIT_FAILURE);
}
