[Spice-devel] [PATCH 1/2] server/tests: add test_display_no_ssl

Hans de Goede hdegoede at redhat.com
Mon Nov 29 01:53:48 PST 2010


Hi,

Looks good in general, but:
1) The ASSERT macro is defined on both test_util.c and test_util.h
2) Why mallocz, what is wrong with calloc ? (which does the same

Regards,

Hans


On 11/28/2010 04:23 PM, Alon Levy wrote:
> updates taken from spice vga mode updates, i.e. non cacheable, glz compressed
> (depends on whatever settings you apply to the server) opaque draw operations.
>   + completed the SpiceCoreInterface implementation (timers)
> ---
>   server/tests/Makefile.am           |   17 ++-
>   server/tests/basic_event_loop.c    |  320 +++++++++++++++++++++++++++++++-----
>   server/tests/test_display_no_ssl.c |  291 ++++++++++++++++++++++++++++++++
>   server/tests/test_util.c           |   21 +++
>   server/tests/test_util.h           |   14 ++
>   5 files changed, 612 insertions(+), 51 deletions(-)
>   create mode 100644 server/tests/test_display_no_ssl.c
>   create mode 100644 server/tests/test_util.c
>   create mode 100644 server/tests/test_util.h
>
> diff --git a/server/tests/Makefile.am b/server/tests/Makefile.am
> index dbae555..c324393 100644
> --- a/server/tests/Makefile.am
> +++ b/server/tests/Makefile.am
> @@ -1,16 +1,21 @@
>   NULL =
>
> -INCLUDES = 	\
> -	-I..		\
> -	$(PROTOCOL_CFLAGS) \
> -	$(SPICE_NONPKGCONFIG_CFLAGS)			\
> +INCLUDES = 							\
> +	-I..							\
> +	-I../../common 					\
> +	$(PROTOCOL_CFLAGS) 				\
> +	$(SPICE_NONPKGCONFIG_CFLAGS)	\
>   	$(NULL)
>
>   LDFLAGS = -L../.libs -lspice-server
>
> -bin_PROGRAMS = test_just_sockets_no_ssl test_empty_success test_fail_on_null_core_interface
> +bin_PROGRAMS = test_just_sockets_no_ssl test_empty_success test_fail_on_null_core_interface test_display_no_ssl
>
> -test_just_sockets_no_ssl_SOURCES = test_just_sockets_no_ssl.c basic_event_loop.c
> +test_display_no_ssl_SOURCES = test_display_no_ssl.c basic_event_loop.c test_util.c
> +
> +test_display_no_ssl_LDFLAGS = $(LDFLAGS)
> +
> +test_just_sockets_no_ssl_SOURCES = test_just_sockets_no_ssl.c basic_event_loop.c test_util.c
>
>   test_just_sockets_no_ssl_LDFLAGS = $(LDFLAGS)
>
> diff --git a/server/tests/basic_event_loop.c b/server/tests/basic_event_loop.c
> index 14dec51..0ae24dc 100644
> --- a/server/tests/basic_event_loop.c
> +++ b/server/tests/basic_event_loop.c
> @@ -1,89 +1,287 @@
>   #include<stdlib.h>
>   #include<stdio.h>
> +#include<sys/time.h>
>
> +#include "test_util.h"
>   #include "basic_event_loop.h"
>
> +int debug = 0;
> +
> +#define DPRINTF(x, format, ...) { \
> +    if (x<= debug) { \
> +        printf("%s: " format "\n" , __FUNCTION__, ## __VA_ARGS__); \
> +    } \
> +}
> +
> +/* From ring.h */
> +typedef struct Ring RingItem;
> +typedef struct Ring {
> +    RingItem *prev;
> +    RingItem *next;
> +} Ring;
> +
> +static inline void ring_init(Ring *ring)
> +{
> +    ring->next = ring->prev = ring;
> +}
> +
> +static inline void ring_item_init(RingItem *item)
> +{
> +    item->next = item->prev = NULL;
> +}
> +
> +static inline int ring_item_is_linked(RingItem *item)
> +{
> +    return !!item->next;
> +}
> +
> +static inline int ring_is_empty(Ring *ring)
> +{
> +    ASSERT(ring->next != NULL&&  ring->prev != NULL);
> +    return ring == ring->next;
> +}
> +
> +static inline void ring_add(Ring *ring, RingItem *item)
> +{
> +    ASSERT(ring->next != NULL&&  ring->prev != NULL);
> +    ASSERT(item->next == NULL&&  item->prev == NULL);
> +
> +    item->next = ring->next;
> +    item->prev = ring;
> +    ring->next = item->next->prev = item;
> +}
> +
> +static inline void __ring_remove(RingItem *item)
> +{
> +    item->next->prev = item->prev;
> +    item->prev->next = item->next;
> +    item->prev = item->next = 0;
> +}
> +
> +static inline void ring_remove(RingItem *item)
> +{
> +    ASSERT(item->next != NULL&&  item->prev != NULL);
> +    ASSERT(item->next != item);
> +
> +    __ring_remove(item);
> +}
> +
> +static inline RingItem *ring_get_head(Ring *ring)
> +{
> +    RingItem *ret;
> +
> +    ASSERT(ring->next != NULL&&  ring->prev != NULL);
> +
> +    if (ring_is_empty(ring)) {
> +        return NULL;
> +    }
> +    ret = ring->next;
> +    return ret;
> +}
> +
> +static inline RingItem *ring_get_tail(Ring *ring)
> +{
> +    RingItem *ret;
> +
> +    ASSERT(ring->next != NULL&&  ring->prev != NULL);
> +
> +    if (ring_is_empty(ring)) {
> +        return NULL;
> +    }
> +    ret = ring->prev;
> +    return ret;
> +}
> +
> +static inline RingItem *ring_next(Ring *ring, RingItem *pos)
> +{
> +    RingItem *ret;
> +
> +    ASSERT(ring->next != NULL&&  ring->prev != NULL);
> +    ASSERT(pos);
> +    ASSERT(pos->next != NULL&&  pos->prev != NULL);
> +    ret = pos->next;
> +    return (ret == ring) ? NULL : ret;
> +}
> +
> +static inline RingItem *ring_prev(Ring *ring, RingItem *pos)
> +{
> +    RingItem *ret;
> +
> +    ASSERT(ring->next != NULL&&  ring->prev != NULL);
> +    ASSERT(pos);
> +    ASSERT(pos->next != NULL&&  pos->prev != NULL);
> +    ret = pos->prev;
> +    return (ret == ring) ? NULL : ret;
> +}
> +
> +#define RING_FOREACH_SAFE(var, next, ring)                    \
> +    for ((var) = ring_get_head(ring),                         \
> +         (next) = (var) ? ring_next(ring, (var)) : NULL;      \
> +            (var);                                            \
> +            (var) = (next),                                   \
> +            (next) = (var) ? ring_next(ring, (var)) : NULL)
> +
> +/**/
> +
>   #define NOT_IMPLEMENTED printf("%s not implemented\n", __func__);
>
>   static SpiceCoreInterface core;
>
> +typedef struct SpiceTimer {
> +    RingItem link;
> +    SpiceTimerFunc func;
> +    struct timeval tv_start;
> +    int ms;
> +    void *opaque;
> +} Timer;
> +
> +Ring timers;
> +
>   static SpiceTimer* timer_add(SpiceTimerFunc func, void *opaque)
>   {
> -    NOT_IMPLEMENTED
> +    SpiceTimer *timer = mallocz(sizeof(SpiceTimer));
> +
> +    timer->func = func;
> +    timer->opaque = opaque;
> +    ring_add(&timers,&timer->link);
> +    return timer;
> +}
> +
> +static void add_ms_to_timeval(struct timeval *tv, int ms)
> +{
> +    tv->tv_usec += 1000 * ms;
> +    while (tv->tv_usec>= 1000000) {
> +        tv->tv_sec++;
> +        tv->tv_usec -= 1000000;
> +    }
>   }
>
>   static void timer_start(SpiceTimer *timer, uint32_t ms)
>   {
> -    NOT_IMPLEMENTED
> +    gettimeofday(&timer->tv_start, NULL);
> +    timer->ms = ms;
> +    // already add ms to timer value
> +    add_ms_to_timeval(&timer->tv_start, ms);
> +    ASSERT(timer->ms);
>   }
>
>   static void timer_cancel(SpiceTimer *timer)
>   {
> -    NOT_IMPLEMENTED
> +    timer->ms = 0;
>   }
>
>   static void timer_remove(SpiceTimer *timer)
>   {
> -    NOT_IMPLEMENTED
> +    ring_remove(&timer->link);
>   }
>
>   struct SpiceWatch {
> -    int id;
> -};
> -
> -typedef struct Watch {
> -    SpiceWatch id;
> +    RingItem link;
>       int fd;
>       int event_mask;
>       SpiceWatchFunc func;
>       void *opaque;
> -} Watch;
> +    int remove;
> +};
> +
> +Ring watches;
>
> -Watch watches[100];
>   int watch_count = 0;
> -int next_id = 1;
>
>   static SpiceWatch *watch_add(int fd, int event_mask, SpiceWatchFunc func, void *opaque)
>   {
> -    watches[watch_count].fd = fd;
> -    watches[watch_count].event_mask = event_mask;
> -    watches[watch_count].func = func;
> -    watches[watch_count].opaque = opaque;
> -    watches[watch_count].id.id = next_id++;
> -    return&watches[watch_count++].id;
> +    SpiceWatch *watch = malloc(sizeof(SpiceWatch));
> +
> +    DPRINTF(0, "adding %p, fd=%d at %d", watch,
> +        fd, watch_count);
> +    watch->fd = fd;
> +    watch->event_mask = event_mask;
> +    watch->func = func;
> +    watch->opaque = opaque;
> +    watch->remove = FALSE;
> +    ring_item_init(&watch->link);
> +    ring_add(&watches,&watch->link);
> +    watch_count++;
> +    return watch;
>   }
>
>   static void watch_update_mask(SpiceWatch *watch, int event_mask)
>   {
> -    int i;
> -    Watch *my_watch;
> -
> -    for (i = 0 ; i<  watch_count; ++i) {
> -        if (watches[i].id.id == watch->id) {
> -            my_watch =&watches[i];
> -            if (my_watch->event_mask != event_mask) {
> -                my_watch->event_mask = event_mask;
> -            }
> -            return;
> -        }
> -    }
> +    DPRINTF(0, "fd %d to %d", watch->fd, event_mask);
> +    watch->event_mask = event_mask;
>   }
>
>   static void watch_remove(SpiceWatch *watch)
>   {
> -    int i;
> +    DPRINTF(0, "remove %p (fd %d)", watch, watch->fd);
> +    ring_remove(&watch->link);
> +    watch->remove = TRUE;
> +    watch_count--;
> +}
>
> -    for (i = 0 ; i<  watch_count ; ++i) {
> -        if (watches[i].id.id == watch->id) {
> -            watches[i] = watches[--watch_count];
> -            return;
> +static void channel_event(int event, SpiceChannelEventInfo *info)
> +{
> +    NOT_IMPLEMENTED
> +}
> +
> +SpiceTimer *get_next_timer(void)
> +{
> +    SpiceTimer *next, *min;
> +
> +    if (ring_is_empty(&timers)) {
> +        return NULL;
> +    }
> +    min = next = (SpiceTimer*)ring_get_head(&timers);
> +    while ((next=(SpiceTimer*)ring_next(&timers,&next->link)) != NULL) {
> +        if (next->ms&&
> +            (next->tv_start.tv_sec<  min->tv_start.tv_sec ||
> +             (next->tv_start.tv_sec == min->tv_start.tv_sec&&
> +              next->tv_start.tv_usec<  min->tv_start.tv_usec))) {
> +             min = next;
>           }
>       }
> +    return min;
>   }
>
> -static void channel_event(int event, SpiceChannelEventInfo *info)
> +struct timeval now;
> +
> +void tv_b_minus_a_return_le_zero(struct timeval *a, struct timeval *b, struct timeval *dest)
>   {
> -    NOT_IMPLEMENTED
> +    dest->tv_usec = b->tv_usec - a->tv_usec;
> +    dest->tv_sec = b->tv_sec - a->tv_sec;
> +    while (dest->tv_usec<  0) {
> +        dest->tv_usec += 1000000;
> +        dest->tv_sec--;
> +    }
> +    if (dest->tv_sec<  0) {
> +        dest->tv_sec = 0;
> +        dest->tv_usec = 0;
> +    }
> +}
> +
> +void calc_next_timeout(SpiceTimer *next, struct timeval *timeout)
> +{
> +    gettimeofday(&now, NULL);
> +    tv_b_minus_a_return_le_zero(&now,&next->tv_start, timeout);
> +}
> +
> +void timeout_timers()
> +{
> +    SpiceTimer *next;
> +    struct timeval left;
> +    int count = 0;
> +
> +    next = (SpiceTimer*)ring_get_head(&timers);
> +    while (next != NULL) {
> +        tv_b_minus_a_return_le_zero(&now,&next->tv_start,&left);
> +        if (next->ms&&  left.tv_usec == 0&&  left.tv_sec == 0) {
> +            count++;
> +            DPRINTF(1, "calling timer");
> +            next->func(next->opaque);
> +        }
> +        next = (SpiceTimer*)ring_next(&timers,&next->link);
> +    }
> +    DPRINTF(1, "called %d timers", count);
>   }
>
>   void basic_event_loop_mainloop(void)
> @@ -92,12 +290,20 @@ void basic_event_loop_mainloop(void)
>       int max_fd = -1;
>       int i;
>       int retval;
> +    SpiceWatch *watch;
> +    SpiceTimer *next_timer;
> +    RingItem *link;
> +    RingItem *next;
> +    struct timeval next_timer_timeout;
> +    struct timeval *timeout;
>
>       while (1) {
>           FD_ZERO(&rfds);
>           FD_ZERO(&wfds);
> -        for (i = 0 ; i<  watch_count; ++i) {
> -            Watch* watch =&watches[i];
> +        watch = (SpiceWatch*)watches.next;
> +        i = 0;
> +        RING_FOREACH_SAFE(link, next,&watches) {
> +            watch = (SpiceWatch*)link;
>               if (watch->event_mask&  SPICE_WATCH_EVENT_READ) {
>                   FD_SET(watch->fd,&rfds);
>                   max_fd = watch->fd>  max_fd ? watch->fd : max_fd;
> @@ -106,21 +312,43 @@ void basic_event_loop_mainloop(void)
>                   FD_SET(watch->fd,&wfds);
>                   max_fd = watch->fd>  max_fd ? watch->fd : max_fd;
>               }
> +            i++;
> +        }
> +        if ((next_timer = get_next_timer()) != NULL) {
> +            calc_next_timeout(next_timer,&next_timer_timeout);
> +            timeout =&next_timer_timeout;
> +            DPRINTF(1, "timeout of %d.%06d",
> +                    timeout->tv_sec, timeout->tv_usec);
> +        } else {
> +            timeout = NULL;
> +        }
> +        DPRINTF(1, "watching %d fds", i);
> +        retval = select(max_fd + 1,&rfds,&wfds, NULL, timeout);
> +        if (timeout != NULL) {
> +            calc_next_timeout(next_timer,&next_timer_timeout);
> +            if (next_timer_timeout.tv_sec == 0&&
> +                next_timer_timeout.tv_usec == 0) {
> +                timeout_timers();
> +            }
>           }
> -        retval = select(max_fd + 1,&rfds,&wfds, NULL, NULL);
>           if (retval == -1) {
>               printf("error in select - exiting\n");
> -            exit(-1);
> +            abort();
>           }
>           if (retval) {
> -            for (i = 0 ; i<  watch_count; ++i) {
> -                Watch* watch =&watches[i];
> -                if ((watch->event_mask&  SPICE_WATCH_EVENT_READ)&&  FD_ISSET(watch->fd,&rfds)) {
> +            RING_FOREACH_SAFE(link, next,&watches) {
> +                watch = (SpiceWatch*)link;
> +                if ((watch->event_mask&  SPICE_WATCH_EVENT_READ)
> +&&  FD_ISSET(watch->fd,&rfds)) {
>                       watch->func(watch->fd, SPICE_WATCH_EVENT_READ, watch->opaque);
>                   }
> -                if ((watch->event_mask&  SPICE_WATCH_EVENT_WRITE)&&  FD_ISSET(watch->fd,&wfds)) {
> +                if (!watch->remove&&  (watch->event_mask&  SPICE_WATCH_EVENT_WRITE)
> +&&  FD_ISSET(watch->fd,&wfds)) {
>                       watch->func(watch->fd, SPICE_WATCH_EVENT_WRITE, watch->opaque);
>                   }
> +                if (watch->remove) {
> +                    free(watch);
> +                }
>               }
>           }
>       }
> @@ -128,6 +356,8 @@ void basic_event_loop_mainloop(void)
>
>   SpiceCoreInterface *basic_event_loop_init(void)
>   {
> +    ring_init(&watches);
> +    ring_init(&timers);
>       bzero(&core, sizeof(core));
>       core.base.major_version = SPICE_INTERFACE_CORE_MAJOR;
>       core.base.minor_version = SPICE_INTERFACE_CORE_MINOR; // anything less then 3 and channel_event isn't called
> diff --git a/server/tests/test_display_no_ssl.c b/server/tests/test_display_no_ssl.c
> new file mode 100644
> index 0000000..ffbe672
> --- /dev/null
> +++ b/server/tests/test_display_no_ssl.c
> @@ -0,0 +1,291 @@
> +#include<stdlib.h>
> +#include<math.h>
> +#include<string.h>
> +#include<stdio.h>
> +#include<sys/select.h>
> +#include<spice.h>
> +#include<spice/qxl_dev.h>
> +#include "red_channel.h"
> +#include "test_util.h"
> +#include "basic_event_loop.h"
> +
> +/* Parts cribbed from spice-display.h/.c/qxl.c */
> +
> +typedef struct SimpleSpiceUpdate {
> +    QXLDrawable drawable;
> +    QXLImage image;
> +    QXLCommandExt ext;
> +    uint8_t *bitmap;
> +} SimpleSpiceUpdate;
> +
> +void test_spice_destroy_update(SimpleSpiceUpdate *update)
> +{
> +    free(update->bitmap);
> +    free(update);
> +}
> +
> +#define WIDTH 800
> +#define HEIGHT 600
> +
> +static float angle = 0;
> +static int unique = 1;
> +static int color = 0;
> +
> +SimpleSpiceUpdate *test_spice_create_update()
> +{
> +    SimpleSpiceUpdate *update;
> +    QXLDrawable *drawable;
> +    QXLImage *image;
> +    QXLCommand *cmd;
> +    QXLRect bbox = {
> +        .top = HEIGHT/2 + (HEIGHT/3)*cos(angle),
> +        .left = WIDTH/2 + (WIDTH/3)*sin(angle),
> +    };
> +    uint8_t *dst;
> +    int bw, bh;
> +    int i;
> +
> +    angle += 0.1;
> +    color = (color + 1) % 10;
> +    unique++;
> +
> +    update   = mallocz(sizeof(*update));
> +    drawable =&update->drawable;
> +    image    =&update->image;
> +    cmd      =&update->ext.cmd;
> +
> +    bw       = 64;
> +    bh       = 48;
> +    bbox.right = bbox.left + bw;
> +    bbox.bottom = bbox.top + bh;
> +    update->bitmap = malloc(bw * bh * 4);
> +    //printf("allocated %p, %p\n", update, update->bitmap);
> +
> +    drawable->bbox            = bbox;
> +    drawable->clip.type       = SPICE_CLIP_TYPE_NONE;
> +    drawable->effect          = QXL_EFFECT_OPAQUE;
> +    drawable->release_info.id = (intptr_t)update;
> +    drawable->type            = QXL_DRAW_COPY;
> +    drawable->surfaces_dest[0] = -1;
> +    drawable->surfaces_dest[1] = -1;
> +    drawable->surfaces_dest[2] = -1;
> +
> +    drawable->u.copy.rop_descriptor  = SPICE_ROPD_OP_PUT;
> +    drawable->u.copy.src_bitmap      = (intptr_t)image;
> +    drawable->u.copy.src_area.right  = bw;
> +    drawable->u.copy.src_area.bottom = bh;
> +
> +    QXL_SET_IMAGE_ID(image, QXL_IMAGE_GROUP_DEVICE, unique);
> +    image->descriptor.type   = SPICE_IMAGE_TYPE_BITMAP;
> +    image->bitmap.flags      = QXL_BITMAP_DIRECT | QXL_BITMAP_TOP_DOWN;
> +    image->bitmap.stride     = bw * 4;
> +    image->descriptor.width  = image->bitmap.x = bw;
> +    image->descriptor.height = image->bitmap.y = bh;
> +    image->bitmap.data = (intptr_t)(update->bitmap);
> +    image->bitmap.palette = 0;
> +    image->bitmap.format = SPICE_BITMAP_FMT_32BIT;
> +
> +    dst = update->bitmap;
> +    for (i = 0 ; i<  bh * bw ; ++i, dst+=4) {
> +        *dst = (color+i % 255);
> +        *(dst+1) = 255 - color;
> +        *(dst+2) = (color * (color + i))&  0xff;
> +        *(dst+3) = 0;
> +    }
> +
> +    cmd->type = QXL_CMD_DRAW;
> +    cmd->data = (intptr_t)drawable;
> +
> +    return update;
> +}
> +
> +#define MEM_SLOT_GROUP_ID 0
> +
> +static QXLWorker *qxl_worker = NULL;
> +static uint8_t primary_surface[HEIGHT * WIDTH * 4];
> +
> +void create_test_primary_surface(QXLWorker *worker)
> +{
> +    QXLDevSurfaceCreate surface;
> +
> +    surface.format     = SPICE_SURFACE_FMT_32_xRGB;
> +    surface.width      = WIDTH;
> +    surface.height     = HEIGHT;
> +    surface.stride     = -WIDTH * 4;
> +    surface.mouse_mode = TRUE;
> +    surface.flags      = 0;
> +    surface.type       = 0;
> +    surface.mem        = (intptr_t)&primary_surface;
> +    surface.group_id   = MEM_SLOT_GROUP_ID;
> +
> +    qxl_worker->create_primary_surface(qxl_worker, 0,&surface);
> +}
> +
> +QXLDevMemSlot slot = {
> +.slot_group_id = MEM_SLOT_GROUP_ID,
> +.slot_id = 0,
> +.generation = 0,
> +.virt_start = 0,
> +.virt_end = ~0,
> +.addr_delta = 0,
> +.qxl_ram_size = ~0,
> +};
> +
> +void attache_worker(QXLInstance *qin, QXLWorker *_qxl_worker)
> +{
> +    static int count = 0;
> +    if (++count>  1) {
> +        printf("%s ignored\n", __func__);
> +        return;
> +    }
> +    printf("%s\n", __func__);
> +    qxl_worker = _qxl_worker;
> +    qxl_worker->add_memslot(qxl_worker,&slot);
> +    create_test_primary_surface(qxl_worker);
> +    qxl_worker->start(qxl_worker);
> +}
> +
> +void set_compression_level(QXLInstance *qin, int level)
> +{
> +    printf("%s\n", __func__);
> +}
> +
> +void set_mm_time(QXLInstance *qin, uint32_t mm_time)
> +{
> +}
> +
> +void get_init_info(QXLInstance *qin, QXLDevInitInfo *info)
> +{
> +    bzero(info, sizeof(*info));
> +    info->num_memslots = 1;
> +    info->num_memslots_groups = 1;
> +    info->memslot_id_bits = 1;
> +    info->memslot_gen_bits = 1;
> +    info->n_surfaces = 1;
> +}
> +
> +#define NOTIFY_BATCH 5
> +
> +int notify = NOTIFY_BATCH;
> +
> +int get_command(QXLInstance *qin, struct QXLCommandExt *ext)
> +{
> +    SimpleSpiceUpdate *update;
> +
> +    if (!notify--) {
> +        return FALSE;
> +    }
> +    update = test_spice_create_update();
> +    *ext = update->ext;
> +    notify = FALSE;
> +    return TRUE;
> +}
> +
> +
> +SpiceTimer *wakeup_timer;
> +int wakeup_ms = 500;
> +
> +int req_cmd_notification(QXLInstance *qin)
> +{
> +    core->timer_start(wakeup_timer, wakeup_ms);
> +    return TRUE;
> +}
> +
> +void do_wakeup()
> +{
> +    notify = NOTIFY_BATCH;
> +    qxl_worker->wakeup(qxl_worker);
> +}
> +
> +void release_resource(QXLInstance *qin, struct QXLReleaseInfoExt release_info)
> +{
> +    //printf("%s\n", __func__);
> +    ASSERT(release_info.group_id == MEM_SLOT_GROUP_ID);
> +    test_spice_destroy_update((void*)release_info.info->id);
> +}
> +
> +int get_cursor_command(QXLInstance *qin, struct QXLCommandExt *cmd)
> +{
> +    //printf("%s\n", __func__);
> +    return FALSE;
> +}
> +
> +int req_cursor_notification(QXLInstance *qin)
> +{
> +    printf("%s\n", __func__);
> +    return TRUE;
> +}
> +
> +void notify_update(QXLInstance *qin, uint32_t update_id)
> +{
> +    printf("%s\n", __func__);
> +}
> +
> +int flush_resources(QXLInstance *qin)
> +{
> +    printf("%s\n", __func__);
> +}
> +
> +QXLInterface display_sif = {
> +    .base = {
> +        .type = SPICE_INTERFACE_QXL,
> +        .description = "test",
> +        .major_version = SPICE_INTERFACE_QXL_MAJOR,
> +        .minor_version = SPICE_INTERFACE_QXL_MINOR
> +    },
> +    .attache_worker = attache_worker,
> +    .set_compression_level = set_compression_level,
> +    .set_mm_time = set_mm_time,
> +    .get_init_info = get_init_info,
> +    .get_command = get_command,
> +    .req_cmd_notification = req_cmd_notification,
> +    .release_resource = release_resource,
> +    .get_cursor_command = get_cursor_command,
> +    .req_cursor_notification = req_cursor_notification,
> +    .notify_update = notify_update,
> +    .flush_resources = flush_resources,
> +};
> +
> +QXLInstance display_sin = {
> +    .base = {
> +        .sif =&display_sif.base,
> +    },
> +    .id = 0,
> +};
> +
> +SpiceServer *server;
> +SpiceCoreInterface *core;
> +SpiceTimer *ping_timer;
> +
> +void show_channels(SpiceServer *server);
> +
> +int ping_ms = 100;
> +
> +void pinger(void *opaque)
> +{
> +    // show_channels is not thread safe - fails if disconnections / connections occur
> +    //show_channels(server);
> +
> +    core->timer_start(ping_timer, ping_ms);
> +}
> +
> +int main()
> +{
> +    core = basic_event_loop_init();
> +    server = spice_server_new();
> +    bzero(primary_surface, sizeof(primary_surface));
> +    spice_server_set_port(server, 5912);
> +    spice_server_set_noauth(server);
> +    spice_server_init(server, core);
> +    //spice_server_set_image_compression(server, SPICE_IMAGE_COMPRESS_OFF);
> +    spice_server_add_interface(server,&display_sin.base);
> +
> +    ping_timer = core->timer_add(pinger, NULL);
> +    wakeup_timer = core->timer_add(do_wakeup, NULL);
> +    core->timer_start(ping_timer, ping_ms);
> +
> +    basic_event_loop_mainloop();
> +
> +    return 0;
> +}
> +
> diff --git a/server/tests/test_util.c b/server/tests/test_util.c
> new file mode 100644
> index 0000000..4cd8069
> --- /dev/null
> +++ b/server/tests/test_util.c
> @@ -0,0 +1,21 @@
> +#include<stdlib.h>
> +#include<strings.h>
> +
> +#include "test_util.h"
> +
> +#define FALSE 0
> +#define TRUE 1
> +
> +#define ASSERT(x) if (!(x)) {                               \
> +    printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
> +    abort();                                                \
> +}
> +
> +
> +void *mallocz(size_t size)
> +{
> +    void *p = malloc(size);
> +    bzero(p, size);
> +    return p;
> +}
> +
> diff --git a/server/tests/test_util.h b/server/tests/test_util.h
> new file mode 100644
> index 0000000..5ef41cb
> --- /dev/null
> +++ b/server/tests/test_util.h
> @@ -0,0 +1,14 @@
> +#ifndef __TEST_UTIL_H__
> +#define __TEST_UTIL_H__
> +
> +#define TRUE 1
> +#define FALSE 0
> +
> +#define ASSERT(x) if (!(x)) {                               \
> +    printf("%s: ASSERT %s failed\n", __FUNCTION__, #x);     \
> +    abort();                                                \
> +}
> +
> +void *mallocz(size_t size);
> +
> +#endif // __TEST_UTIL_H__


More information about the Spice-devel mailing list