test_labcomm_generated_encoding.c 3.85 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
  labcomm_encoder_register_generated_encoding_V(encoder);
154
  EXPECT({ 0x02, -1, 0x01, 'V', 0x11, 0x00 });
155
156
157

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

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

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

  return 0;
}