← Back to branch summary

~ubuntu-branches/ubuntu/trusty/geis/trusty

« back to all changes in this revision

Viewing changes to testsuite/geis2/check_subscription.c

  • Committer: Package Import Robot
  • Author(s): Chase Douglas
  • Date: 2012-07-30 08:51:42 UTC
  • Revision ID: package-import@ubuntu.com-20120730085142-jrc33ygjvt0ob1wl
Tags: upstream-2.2.11
Import upstream version 2.2.11

Show diffs side-by-side

added added

removed removed

Lines of Context:
testsuite/geis2/check_subscription.c
 
1
/**
 
2
 * Unit tests for GEIS v2.0 subsciption module
 
3
 */
 
4
#include <check.h>
 
5
 
 
6
#include <geis/geis.h>
 
7
#include "libgeis/geis_test_api.h"
 
8
#include <string.h>
 
9
 
 
10
 
 
11
/* fixtures */
 
12
static Geis g_geis;
 
13
 
 
14
/* fixture setup */
 
15
static void
 
16
construct_geis()
 
17
{
 
18
  g_geis = geis_new(GEIS_INIT_MOCK_BACKEND,
 
19
                    GEIS_INIT_TRACK_DEVICES,
 
20
                    GEIS_INIT_TRACK_GESTURE_CLASSES,
 
21
                    NULL);
 
22
}
 
23
 
 
24
/* fixture teardown */
 
25
static void
 
26
destroy_geis()
 
27
{
 
28
  geis_delete(g_geis);
 
29
}
 
30
 
 
31
 
 
32
/* compile-time test to ensure required types are defined */
 
33
START_TEST(subscription_constants)
 
34
{
 
35
  GeisSubscriptionFlags f;
 
36
  f = GEIS_SUBSCRIPTION_NONE
 
37
   | GEIS_SUBSCRIPTION_GRAB
 
38
   | GEIS_SUBSCRIPTION_CONT;
 
39
}
 
40
END_TEST
 
41
 
 
42
START_TEST(construction)
 
43
{
 
44
  GeisSubscription sub = geis_subscription_new(g_geis,
 
45
                                               "name",
 
46
                                               GEIS_SUBSCRIPTION_NONE);
 
47
  fail_unless(sub != NULL,
 
48
              "failed to create subscription");
 
49
  fail_unless(0 == strcmp(geis_subscription_name(sub), "name"),
 
50
              "unexpected subscription name returned");
 
51
  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_activate(sub),
 
52
              "unable to activate subscription");
 
53
  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_deactivate(sub),
 
54
              "unable to deactivate subscription");
 
55
  geis_subscription_delete(sub);
 
56
}
 
57
END_TEST
 
58
 
 
59
 
 
60
START_TEST(filter)
 
61
{
 
62
  GeisFilter filter = geis_filter_new(g_geis, "filter");
 
63
  GeisSubscription sub = geis_subscription_new(g_geis,
 
64
                                               "name",
 
65
                                               GEIS_SUBSCRIPTION_NONE);
 
66
  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_add_filter(sub, filter),
 
67
              "filter add fail");
 
68
 
 
69
  filter = geis_subscription_filter_by_name(sub, "bogus");
 
70
  fail_unless(filter == NULL,
 
71
              "bogus filter retrieval fail");
 
72
  filter = geis_subscription_filter_by_name(sub, "filter");
 
73
  fail_unless(filter != NULL,
 
74
              "filter retrieval fail");
 
75
 
 
76
  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_remove_filter(sub, filter),
 
77
              "filter remove fail");
 
78
}
 
79
END_TEST
 
80
 
 
81
 
 
82
START_TEST(device_filter)
 
83
{
 
84
  GeisStatus status;
 
85
  GeisEvent event;
 
86
 
 
87
  GeisSubscription sub = geis_subscription_new(g_geis,
 
88
                                               "devices",
 
89
                                               GEIS_SUBSCRIPTION_NONE);
 
90
 
 
91
  while (geis_dispatch_events(g_geis) == GEIS_STATUS_CONTINUE)
 
92
    ;
 
93
  status = geis_next_event(g_geis, &event);
 
94
  while (status == GEIS_STATUS_SUCCESS || status == GEIS_STATUS_CONTINUE)
 
95
  {
 
96
    if (geis_event_type(event) == GEIS_EVENT_DEVICE_AVAILABLE)
 
97
    {
 
98
      GeisAttr   attr;
 
99
      GeisDevice device;
 
100
      GeisFilter filter;
 
101
      GeisStatus fs;
 
102
 
 
103
      attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_DEVICE);
 
104
      fail_if (!attr, "geis-device attr not found in device event");
 
105
 
 
106
      device = geis_attr_value_to_pointer(attr);
 
107
      fail_if (!device, "geis device not found in device event");
 
108
 
 
109
      filter = geis_filter_new(g_geis, "device filter");
 
110
      fail_if(!filter, "can not create filter");
 
111
 
 
112
      fs = geis_filter_add_term(filter, GEIS_FILTER_DEVICE,
 
113
          GEIS_DEVICE_ATTRIBUTE_NAME, GEIS_FILTER_OP_NE, geis_device_name(device),
 
114
          NULL);
 
115
      fail_if(fs != GEIS_STATUS_SUCCESS, "can not add device to filter");
 
116
 
 
117
      fs = geis_subscription_add_filter(sub, filter);
 
118
      fail_if(fs != GEIS_STATUS_SUCCESS, "can not subscribe filter");
 
119
    }
 
120
    else if (geis_event_type(event) == GEIS_EVENT_CLASS_AVAILABLE)
 
121
    {
 
122
      GeisAttr         attr;
 
123
      GeisGestureClass gesture_class;
 
124
      GeisFilter       filter;
 
125
      GeisStatus       fs;
 
126
 
 
127
      attr = geis_event_attr_by_name(event, GEIS_EVENT_ATTRIBUTE_CLASS);
 
128
      fail_if (!attr, "attr not found in class event");
 
129
 
 
130
      gesture_class = geis_attr_value_to_pointer(attr);
 
131
      fail_if (!gesture_class, "geis class not found in class event");
 
132
 
 
133
      filter = geis_filter_new(g_geis, "class filter");
 
134
      fail_if(!filter, "can not create filter");
 
135
 
 
136
      fs = geis_filter_add_term(filter, GEIS_FILTER_CLASS,
 
137
          GEIS_CLASS_ATTRIBUTE_NAME, GEIS_FILTER_OP_NE, geis_gesture_class_name(gesture_class),
 
138
          NULL);
 
139
      fail_if(fs != GEIS_STATUS_SUCCESS, "can not add class to filter");
 
140
 
 
141
      fs = geis_subscription_add_filter(sub, filter);
 
142
      fail_if(fs != GEIS_STATUS_SUCCESS, "can not subscribe filter");
 
143
    }
 
144
    geis_event_delete(event);
 
145
 
 
146
    if (status == GEIS_STATUS_CONTINUE)
 
147
    {
 
148
      status = geis_next_event(g_geis, &event);
 
149
    }
 
150
    else
 
151
    {
 
152
      break;
 
153
    }
 
154
  }
 
155
 
 
156
  fail_unless(GEIS_STATUS_SUCCESS == geis_subscription_activate(sub),
 
157
              "unable to activate subscription");
 
158
}
 
159
END_TEST
 
160
 
 
161
 
 
162
/* boilerplate */
 
163
Suite *
 
164
geis2_subscription_suite_new()
 
165
{
 
166
  TCase *create;
 
167
  TCase *usage;
 
168
  Suite *s = suite_create("geis2_subscriptions");
 
169
 
 
170
  create = tcase_create("subscription-constants");
 
171
  tcase_add_test(create, subscription_constants);
 
172
  suite_add_tcase(s, create);
 
173
 
 
174
  usage = tcase_create("subscription-usage");
 
175
  tcase_add_checked_fixture(usage, construct_geis, destroy_geis);
 
176
  tcase_add_test(usage, construction);
 
177
  tcase_add_test(usage, filter);
 
178
  tcase_add_test(usage, device_filter);
 
179
  suite_add_tcase(s, usage);
 
180
 
 
181
  return s;
 
182
}
 
183