test_labcomm_generated_encoding.c 3.74 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include "labcomm_private.h"
#include "labcomm_private.h"
#include "test/gen/generated_encoding.h"

#define IOCTL_WRITER_ASSERT_BYTES 4096
#define IOCTL_WRITER_RESET 4097

static unsigned char buffer[128];
12
struct labcomm_writer *writer;
13

14
static int buf_writer_alloc(struct labcomm_writer *w, void *context,
15
			    struct labcomm_encoder *encoder,
16
			    char *labcomm_version)
17
{
18
  writer = w; /* Hack */
19
20
21
22
23
24
25
26
  w->data_size = sizeof(buffer);
  w->count = w->data_size;
  w->data = buffer;
  w->pos = 0;
  
  return 0;
}

27
static int buf_writer_free(struct labcomm_writer *w, void *context)
28
29
30
31
{
  return 0;
}

32
static int buf_writer_start(struct labcomm_writer *w, void *context,
33
34
			    struct labcomm_encoder *encoder,
			    int index,
35
			    struct labcomm_signature *signature,
36
37
38
39
40
			    void *value)
{
  return 0;
}

41
static int buf_writer_end(struct labcomm_writer *w, void *context)
42
43
44
45
{
  return 0;
}

46
static int buf_writer_flush(struct labcomm_writer *w, void *context)
47
48
49
50
51
52
53
54
{
  fprintf(stderr, "Should not come here %s:%d\n", __FILE__, __LINE__);
  exit(1);
  
  return 0;
}

static int buf_writer_ioctl(
55
  struct labcomm_writer *w, void *context,
56
57
  int signature_index, struct labcomm_signature *signature,
  int action, va_list arg)
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
{
  int result = -ENOTSUP;
  switch (action) {
    case IOCTL_WRITER_ASSERT_BYTES: {
      int line = va_arg(arg, int);
      int count = va_arg(arg, int);
      int *expected = va_arg(arg, int *);
      int i, mismatch;

      if (w->pos != count) {
	fprintf(stderr, "Invalid length encoded %d != %d (%s:%d)\n", 
		w->pos, count, __FILE__, line);
	mismatch = 1;
      } 
      for (mismatch = 0, i = 0 ; i < count ; i++) {
	if (expected[i] >= 0 && expected[i] != buffer[i]) {
	  mismatch = 1;
	}
      }
      if (mismatch) {
	fprintf(stderr, "Encoder mismatch (%s:%d)\n",
		__FILE__, line);

	for (i = 0 ; i < w->pos ; i++) {
	  printf("%2.2x ", w->data[i]);
	}
	printf("\n");
	for (i = 0 ; i < count ; i++) {
	  if (expected[i] < 0) {
	    printf(".. ");
	  } else {
	    printf("%2.2x ", expected[i] );
	  }
	}
	printf("\n");
	exit(1);
      }
      result = 0;
    } break;
    case IOCTL_WRITER_RESET: {
      w->pos = 0;
      result = 0;
    }
  }
  return result;
}

105
const struct labcomm_writer_action writer_action = {
106
107
108
109
110
111
112
  .alloc = buf_writer_alloc,
  .free = buf_writer_free,
  .start = buf_writer_start,
  .end = buf_writer_end,
  .flush = buf_writer_flush,
  .ioctl = buf_writer_ioctl
};
113

114
115
116
117
118
119
120
121
122
123
static struct labcomm_writer buffer_writer = {
  .context = NULL,
  .data = buffer,
  .data_size = sizeof(buffer),
  .count = sizeof(buffer),
  .pos = 0,
  .error = 0,
  .action = &writer_action,
};

124
void dump_encoder(struct labcomm_encoder *encoder)
125
126
127
{
  int i;
  
128
129
  for (i = 0 ; i < writer->pos ; i++) {
    printf("%2.2x ", writer->data[i]);
130
131
132
133
  }
  printf("\n");
}

134
135
136
137
138
139
140
141
142
#define EXPECT(...)							\
  {									\
    int expected[] = __VA_ARGS__;					\
    labcomm_encoder_ioctl(encoder, IOCTL_WRITER_ASSERT_BYTES,		\
			  __LINE__,					\
			  sizeof(expected)/sizeof(expected[0]),		\
			  expected);					\
  }

143
144
145
146
147
int main(void)
{
  generated_encoding_V V;
  generated_encoding_B B = 1;

148
  struct labcomm_encoder *encoder = labcomm_encoder_new(&buffer_writer, 
149
							NULL);
150
151
152

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encoder_register_generated_encoding_V(encoder);
153
  EXPECT({ 0x02, -1, 0x01, 'V', 0x11, 0x00 });
154
155
156

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encoder_register_generated_encoding_B(encoder);
157
  EXPECT({0x02, -1, 0x01, 'B', 0x21});
158
159
160

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encode_generated_encoding_V(encoder, &V);
161
  EXPECT({-1});
162
163
164

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encode_generated_encoding_B(encoder, &B);
165
  EXPECT({-1, 1});
166
167
168
169

  return 0;
}