← Back to branch summary

~ubuntu-branches/ubuntu/maverick/telepathy-salut/maverick

« back to all changes in this revision

Viewing changes to tests/test-r-multicast-sender.c

  • Committer: Bazaar Package Importer
  • Author(s): Sjoerd Simons
  • Date: 2007-06-13 10:54:25 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070613105425-mwwsplxbk8n6z5t6
Tags: 0.1.3-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-r-multicast-sender.c
 
1
#include <stdio.h>
 
2
#include <stdlib.h>
 
3
#include <string.h>
 
4
 
 
5
#include <gibber/gibber-r-multicast-sender.h>
 
6
 
 
7
#define SENDER "testsender"
 
8
 
 
9
#define REPAIR_PACKET ((guint32)15)
 
10
 
 
11
#define EXTRA_SEEN ((guint32)11)
 
12
#define NR_PACKETS ((guint32)40)
 
13
 
 
14
guint32 serial_offset;
 
15
int expected;
 
16
 
 
17
typedef struct {
 
18
  const gchar *id;
 
19
  guint32 expected_packet;
 
20
} recv_t;
 
21
 
 
22
GMainLoop *loop;
 
23
 
 
24
GibberRMulticastPacket *
 
25
generate_packet(guint32 serial) {
 
26
  GibberRMulticastPacket *p;
 
27
  guint8 part = 0, total = 1;
 
28
  gchar *payload;
 
29
  int i;
 
30
  recv_t receivers[] =  
 
31
    { { "receiver1", 500 }, { "receiver2", 600 }, { NULL, 0 } };
 
32
 
 
33
  p = gibber_r_multicast_packet_new(PACKET_TYPE_DATA, SENDER, serial, 1500);
 
34
  if (serial % 3 > 0) {
 
35
    part = serial % 3 - 1;
 
36
    total = 2;
 
37
  }
 
38
 
 
39
  gibber_r_multicast_packet_set_part(p, part, total);
 
40
 
 
41
  for (i = 0 ; receivers[i].id != NULL; i++) {
 
42
    gibber_r_multicast_packet_add_receiver(p, 
 
43
        receivers[i].id, receivers[i].expected_packet, NULL);
 
44
  }
 
45
 
 
46
  payload = g_strdup_printf("%010d\n", serial);
 
47
  gibber_r_multicast_packet_add_payload(p, (guint8 *)payload, strlen(payload));
 
48
  g_free(payload);
 
49
  return p;
 
50
}
 
51
 
 
52
void
 
53
data_received_cb(GibberRMulticastSender *sender, guint8 *data, 
 
54
    gsize size, gpointer user_data) {
 
55
  gchar *str;
 
56
  gchar **lines;
 
57
  int i;
 
58
  str = g_strndup((const gchar *)data, size);
 
59
 
 
60
  lines = g_strsplit(str, "\n", 0);
 
61
  for (i = 0 ; lines[i] != NULL && *lines[i] != '\0'; i++) {
 
62
    int v = atoi(lines[i]);
 
63
 
 
64
    g_assert(v == expected);
 
65
    expected++;
 
66
  }
 
67
  /* serial % 3 is send out in a single packet the other two together.
 
68
   * So expected can't be  % 3 == 2 here */
 
69
  g_assert(expected % 3 != 2);
 
70
 
 
71
  if (expected == serial_offset + NR_PACKETS
 
72
      || expected == serial_offset + NR_PACKETS + EXTRA_SEEN) {
 
73
    g_main_loop_quit((GMainLoop *)user_data);
 
74
  }
 
75
 
 
76
  g_strfreev(lines);
 
77
  g_free(str);
 
78
 
 
79
}
 
80
 
 
81
void
 
82
repair_request_cb(GibberRMulticastSender *sender, guint id, gpointer data) {
 
83
  GibberRMulticastPacket *p;
 
84
 
 
85
  g_assert(gibber_r_multicast_packet_diff(serial_offset, id) >= 0 
 
86
           || gibber_r_multicast_packet_diff(id, 
 
87
                  serial_offset + NR_PACKETS + EXTRA_SEEN) < 0);
 
88
 
 
89
  p = generate_packet(id);
 
90
  gibber_r_multicast_sender_push(sender, p);
 
91
  g_object_unref(p);
 
92
}
 
93
 
 
94
void
 
95
repair_message_cb(GibberRMulticastSender *sender,
 
96
                  GibberRMulticastPacket *packet,
 
97
                  gpointer user_data) {
 
98
  g_assert(packet->packet_id == REPAIR_PACKET + serial_offset);
 
99
 
 
100
  g_main_loop_quit((GMainLoop *)user_data);
 
101
}
 
102
 
 
103
static gboolean
 
104
add_packet(gpointer data) {
 
105
  static guint32 i = 0;
 
106
  GibberRMulticastSender *sender = GIBBER_R_MULTICAST_SENDER(data);
 
107
  GibberRMulticastPacket *p;
 
108
 
 
109
  if (i == NR_PACKETS) {
 
110
    i = 0;
 
111
    return FALSE;
 
112
  }
 
113
 
 
114
  if (i % 5 != 3) {
 
115
    p = generate_packet(i + serial_offset);
 
116
    gibber_r_multicast_sender_push(sender, p);
 
117
    g_object_unref(p);
 
118
  }
 
119
 
 
120
  i++;
 
121
  return TRUE;
 
122
}
 
123
 
 
124
static gboolean
 
125
timeout_cb(gpointer data) {
 
126
  printf("Test timeout\n");
 
127
  g_assert_not_reached();
 
128
 
 
129
  return FALSE;
 
130
}
 
131
 
 
132
 
 
133
void
 
134
do_test(gboolean test_seen) {
 
135
  guint timeout;
 
136
  GibberRMulticastSender *s;
 
137
 
 
138
  fprintf(stderr, "Starting test with offset %x %d\n", 
 
139
      serial_offset, test_seen);
 
140
 
 
141
  s = gibber_r_multicast_sender_new(SENDER);
 
142
  g_signal_connect(s, "data-received", G_CALLBACK(data_received_cb), loop);
 
143
  g_signal_connect(s, "repair-request", G_CALLBACK(repair_request_cb), loop);
 
144
 
 
145
  if (test_seen) {
 
146
    gibber_r_multicast_sender_seen(s, serial_offset);
 
147
  } else {
 
148
   gibber_r_multicast_sender_repair_request(s, serial_offset);
 
149
  }
 
150
 
 
151
  g_timeout_add(100, add_packet, s);
 
152
  timeout = g_timeout_add(20000, timeout_cb, loop);
 
153
 
 
154
  g_main_loop_run(loop);
 
155
 
 
156
  /* tell the sender we've seen some extra pakcets */
 
157
  gibber_r_multicast_sender_seen(s, serial_offset + NR_PACKETS + EXTRA_SEEN);
 
158
  g_main_loop_run(loop);
 
159
 
 
160
  /* Ask for a repair */
 
161
  g_signal_connect(s, "repair-message", G_CALLBACK(repair_message_cb), loop);
 
162
 
 
163
  gibber_r_multicast_sender_repair_request(s, serial_offset + REPAIR_PACKET);
 
164
 
 
165
  g_main_loop_run(loop);
 
166
 
 
167
  g_source_remove(timeout);
 
168
  g_object_unref(s);
 
169
}
 
170
 
 
171
 
 
172
int
 
173
main(int argc, char **argv) {
 
174
  g_type_init();
 
175
  loop = g_main_loop_new(NULL, FALSE);
 
176
 
 
177
  serial_offset = ((guint32)(~0 - NR_PACKETS/2));
 
178
  expected = serial_offset;
 
179
  do_test(TRUE);
 
180
 
 
181
  serial_offset = 0xff;
 
182
  expected = serial_offset;
 
183
  do_test(TRUE);
 
184
 
 
185
  serial_offset = 0xff;
 
186
  expected = serial_offset;
 
187
  do_test(FALSE);
 
188
 
 
189
  return 0;
 
190
}