adding new test

Sanity/basic/main.fmf

@@ -0,0 +1,30 @@
+summary: Test basic libevent functionality
+description: ''
+contact: Petr Dancak <pdancak@redhat.com>
+component:
+- libevent
+test: ./runtest.sh
+framework: beakerlib
+recommend:
+- libevent
+- libevent-devel
+- gcc
+duration: 5m
+enabled: true
+tag:
+- NoRHEL4
+- NoRHEL5
+- TIPfail_infra
+- TIPpass
+- Tier1
+- rhel-buildroot
+- rhel8-buildroot
+- rhel9-buildroot
+tier: '1'
+adjust:
+-   enabled: false
+    when: distro < rhel-8
+    continue: false
+extra-nitrate: TC#0608020
+extra-summary: /CoreOS/libevent/Sanity/basic
+extra-task: /CoreOS/libevent/Sanity/basic

Sanity/basic/runtest.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# SPDX-License-Identifier: LGPL-2.1+
+# ~~~
+#   runtest.sh of /CoreOS/libevent/Sanity/basic
+#   Description: Test basic libevent functionality
+#
+#   Author: Susant Sahani <susant@redhat.com>
+#   Copyright (c) 2018 Red Hat, Inc.
+# ~~~
+
+# Include Beaker environment
+. /usr/share/beakerlib/beakerlib.sh || exit 1
+
+PACKAGE="libevent"
+
+rlJournalStart
+    rlPhaseStartSetup
+        rlAssertRpm $PACKAGE
+        rlRun "TmpDir=\$(mktemp -d)" 0 "Creating tmp directory"
+	rlRun "cp test-libevent.c $TmpDir"
+        rlRun "pushd $TmpDir"
+    rlPhaseEnd
+
+    rlPhaseStartTest
+        rlRun "gcc -Wall -g3 test-libevent.c -o test-libevent -levent -lpthread"
+        rlLog "Starting libevent tests ..."
+        rlRun "./test-libevent"
+    rlPhaseEnd
+
+    rlPhaseStartCleanup
+        rlRun "popd"
+        rlRun "rm -r $TmpDir" 0 "Removing tmp directory"
+    rlPhaseEnd
+rlJournalPrintText
+rlJournalEnd

Sanity/basic/test-libevent.c

@@ -0,0 +1,234 @@
+/*
+# SPDX-License-Identifier: LGPL-2.1+
+# ~~~
+#   Description: libevent tests
+#
+#   Author: Susant Sahani <susant@redhat.com>
+#   Copyright (c) 2018 Red Hat, Inc.
+# ~~~
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <event2/event.h>
+#include <event2/dns.h>
+#include <event2/listener.h>
+#include <event2/bufferevent.h>
+#include <event2/buffer.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <signal.h>
+#include <assert.h>
+
+#define UNIX_SOCK_PATH "/var/run/mysocket"
+
+void evdns_cb(int result, char type, int count, int ttl, void *addresses, void *arg) {
+	unsigned char *addr = (char *) addresses;
+        int i;
+
+        assert(result == DNS_ERR_NONE);
+
+        printf("type: %s", type == DNS_IPv4_A ? "DNS_IPv4_A" : type == DNS_PTR ? "DNS_PTR" : "DNS_IPv6_AAAA");
+        printf("ttl:  %d", ttl);
+
+        for(i = 0 ; i < count ; i++)
+                printf("address[%d]:%d.%d.%d.%d\n", i + 1, addr[0 + i*4], addr[1 + i*4], addr[2 + i*4], addr[3 + i*4]);
+
+	evdns_base_clear_nameservers_and_suspend((struct evdns_base *) arg);
+}
+
+void test_dns_resolve_ipv4(void) {
+        struct event_base *event_base = NULL;
+        struct evdns_base *evdns_base = NULL;
+        struct evdns_request *req;
+
+	assert((event_base = event_base_new()));
+	assert((evdns_base =  evdns_base_new(event_base,  0)));
+
+	assert(evdns_base_resolv_conf_parse(evdns_base, DNS_OPTION_NAMESERVERS, "/etc/resolv.conf") == 0);
+
+        assert(evdns_base_count_nameservers(evdns_base) > 0);
+
+	assert((req = evdns_base_resolve_ipv4(evdns_base, "redhat.com", 0, evdns_cb, evdns_base)));
+
+	event_base_dispatch(event_base);
+
+	event_base_free(event_base);
+	evdns_base_free(evdns_base, 0);
+}
+
+static int signal_test;
+static void signal_cb(evutil_socket_t fd, short event, void *arg) {
+	struct event *signal = arg;
+
+        assert(arg);
+
+        signal_test = 1;
+        event_base_loopexit((struct event_base *) arg, NULL);
+
+}
+
+void test_signal(void){
+	struct event *signal_int;
+	struct event_base* base;
+        pthread_t client_thread;
+
+	base = event_base_new();
+	assert((signal_int = evsignal_new(base, SIGUSR1, signal_cb, base)));
+
+	event_add(signal_int, NULL);
+        raise(SIGUSR1);
+	event_base_dispatch(base);
+
+        assert(signal_test == 1);
+
+	event_free(signal_int);
+	event_base_free(base);
+}
+
+void test_event_reader_timer_callback(int fd, short event, void *arg) {
+        event_base_loopexit((struct event_base *) arg, NULL);
+        assert(0);
+}
+
+void *writer_client_thread(void *p) {
+        struct sockaddr_un addr;
+        struct sockaddr_un from;
+        char buf[8192];
+        int fd;
+
+        assert((fd = socket(PF_UNIX, SOCK_STREAM, 0)) >= 0);
+
+        memset(&addr, 0, sizeof(addr));
+        addr.sun_family = AF_UNIX;
+        strcpy(addr.sun_path, UNIX_SOCK_PATH);
+
+        assert(connect(fd, (struct sockaddr *)&addr, sizeof(addr)) >= 0);
+
+        strcpy(buf, "test");
+        assert(send(fd, buf, strlen(buf) + 1, 0) >= 0);
+
+        close(fd);
+
+        return 0;
+}
+
+static void echo_read_cb(struct bufferevent *bev, void *ctx) {
+        struct evbuffer *input = bufferevent_get_input(bev);
+        struct evbuffer *output = bufferevent_get_output(bev);
+        struct event_base *base = bufferevent_get_base(bev);
+        size_t len = evbuffer_get_length(input);
+        static char client_buf[64];
+
+        assert(input);
+        assert(output);
+        assert(base);
+        assert(len > 0);
+
+        assert(evbuffer_copyout(input, client_buf, len) >= 0);
+        assert(evbuffer_add_buffer(output, input) >= 0);
+
+        assert(!strcmp(client_buf, "test"));
+
+        unlink(UNIX_SOCK_PATH);
+        event_base_loopexit(base, NULL);
+}
+
+static void echo_event_cb(struct bufferevent *bev, short events, void *ctx) {
+
+        if (events & BEV_EVENT_ERROR)
+                perror("Error from bufferevent");
+
+        if (events & (BEV_EVENT_EOF | BEV_EVENT_ERROR)) {
+                bufferevent_free(bev);
+        }
+
+        assert(0);
+}
+
+static void accept_conn_cb(struct evconnlistener *listener, evutil_socket_t fd, struct sockaddr *address, int socklen, void *ctx) {
+        struct event_base *base = evconnlistener_get_base(listener);
+        struct bufferevent *bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
+
+        assert(base);
+        assert(bev);
+
+        bufferevent_setcb(bev, echo_read_cb, NULL, echo_event_cb, NULL);
+        bufferevent_enable(bev, EV_READ | EV_WRITE);
+}
+
+static void accept_error_cb(struct evconnlistener *listener, void *ctx) {
+        struct event_base *base = evconnlistener_get_base(listener);
+        int err = EVUTIL_SOCKET_ERROR();
+
+        assert(base);
+
+        fprintf(stderr, "Got an error %d (%s) on the listener. Shutting down.\n", err, evutil_socket_error_to_string(err));
+
+        assert(0);
+        event_base_loopexit(base, NULL);
+}
+
+void test_event_reader(void) {
+        struct evconnlistener *listener;
+        struct timeval three_sec = { 3, 0 };
+        struct event_base *base;
+        struct sockaddr_un sin;
+        pthread_t client_thread;
+        struct itimerval tval;
+        struct event *ev;
+
+        assert((base = event_base_new()));
+        assert((ev = event_new(base, -1, EV_TIMEOUT, test_event_reader_timer_callback, (void *) base)));
+        event_add(ev, &three_sec);
+
+        memset(&sin, 0, sizeof(sin));
+        sin.sun_family = AF_LOCAL;
+        strcpy(sin.sun_path, UNIX_SOCK_PATH);
+
+        assert((listener = evconnlistener_new_bind(base, accept_conn_cb, NULL,
+                                                            LEV_OPT_CLOSE_ON_FREE | LEV_OPT_REUSEABLE, -1,
+                                                            (struct sockaddr *) &sin, sizeof(sin))));
+        evconnlistener_set_error_cb(listener, accept_error_cb);
+
+        assert(pthread_create(&client_thread, NULL, *writer_client_thread, (void *) NULL) >= 0);
+        event_base_dispatch(base);
+
+        sleep(1);
+
+        pthread_join(client_thread, NULL);
+}
+
+void test_timer_callback(int fd, short event, void *arg) {
+        int *x = (int *) arg;
+
+        *x = 10;
+}
+
+void test_timer(void) {
+        struct timeval one_sec = { 1, 0 };
+        struct event_base *base;
+        struct event *ev;
+        static int x;
+
+        assert((base = event_base_new()));
+        assert((ev = event_new(base, -1, EV_TIMEOUT, test_timer_callback, (void *) &x)));
+        event_add(ev, &one_sec);
+        event_base_dispatch(base);
+
+        sleep(2);
+        assert(10 == x);
+}
+
+int main(int argc, char *argv[]) {
+        test_timer();
+        test_event_reader();
+        test_signal();
+        test_dns_resolve_ipv4();
+}