test_labcomm_generated_encoding.c 3.41 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
15
static int buf_writer_alloc(struct labcomm_writer *w, char *labcomm_version)
{
16
  writer = w; /* Hack */
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
  w->data_size = sizeof(buffer);
  w->count = w->data_size;
  w->data = buffer;
  w->pos = 0;
  
  return 0;
}

static int buf_writer_free(struct labcomm_writer *w)
{
  return 0;
}

static int buf_writer_start(struct labcomm_writer *w,
			    struct labcomm_encoder *encoder,
			    int index,
33
			    struct labcomm_signature *signature,
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
			    void *value)
{
  return 0;
}

static int buf_writer_end(struct labcomm_writer *w)
{
  return 0;
}

static int buf_writer_flush(struct labcomm_writer *w)
{
  fprintf(stderr, "Should not come here %s:%d\n", __FILE__, __LINE__);
  exit(1);
  
  return 0;
}

static int buf_writer_ioctl(
53
54
  struct labcomm_writer *w, 
  int action, 
55
  struct labcomm_signature *signature,
56
  va_list arg)
57
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
{
  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;
}

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

113
void dump_encoder(struct labcomm_encoder *encoder)
114
115
116
{
  int i;
  
117
118
  for (i = 0 ; i < writer->pos ; i++) {
    printf("%2.2x ", writer->data[i]);
119
120
121
122
  }
  printf("\n");
}

123
124
125
126
127
128
129
130
131
#define EXPECT(...)							\
  {									\
    int expected[] = __VA_ARGS__;					\
    labcomm_encoder_ioctl(encoder, IOCTL_WRITER_ASSERT_BYTES,		\
			  __LINE__,					\
			  sizeof(expected)/sizeof(expected[0]),		\
			  expected);					\
  }

132
133
134
135
136
int main(void)
{
  generated_encoding_V V;
  generated_encoding_B B = 1;

137
  struct labcomm_encoder *encoder = labcomm_encoder_new(buffer_writer, buffer,
138
						   NULL, NULL);
139
140
141

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encoder_register_generated_encoding_V(encoder);
142
  EXPECT({ 0x02, -1, 0x01, 'V', 0x11, 0x00 });
143
144
145

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encoder_register_generated_encoding_B(encoder);
146
  EXPECT({0x02, -1, 0x01, 'B', 0x21});
147
148
149

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encode_generated_encoding_V(encoder, &V);
150
  EXPECT({-1});
151
152
153

  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
  labcomm_encode_generated_encoding_B(encoder, &B);
154
  EXPECT({-1, 1});
155
156
157
158

  return 0;
}