Commit ed186dc8 authored by Anders Blomdell's avatar Anders Blomdell
Browse files

Restart of labcomm_decode_one in case of insufficient data implemented.

parent 36eec9dc
......@@ -38,3 +38,4 @@ lib/c/liblabcomm_plain_c.so.1
lib/c/test/test_signature_plain_c
test/test_signature_numbers
lib/c/test/test_signature_numbers
lib/c/test/test_labcomm
## Macros
CC=gcc
#CFLAGS=-g -Wall -Werror -O3 -I. -Itest -DLABCOMM_ENCODER_LINEAR_SEARCH
CFLAGS=-g -Wall -Werror -O3 -I. -Itest
LDFLAGS=-L.
LDLIBS_TEST=-llabcomm -lrt
......@@ -23,18 +22,15 @@ LABCOMM_JAR=../../compiler/labComm.jar
LABCOMM=java -jar $(LABCOMM_JAR)
TESTS=test_labcomm_basic_type_encoding test_labcomm_generated_encoding \
test_signature_numbers \
test_labcomm \
test_labcomm_pthread_scheduler \
test_signature_numbers
#
#FIXME: test_labcomm test_labcomm_errors
TEST_DIR=test
TESTDATA_DIR=$(TEST_DIR)/testdata
TEST_GEN_DIR=$(TESTDATA_DIR)/gen
VPATH=$(TEST_DIR)
CREATED_DIRS=$(TEST_DIR) $(TESTDATA_DIR) $(TEST_GEN_DIR)
# Enable experimental objects by invoking make like `make LABCOMM_EXPERIMENTAL=true`
ifeq ($(LABCOMM_EXPERIMENTAL),true)
OBJS += experimental/udp_hack.o experimental/ethaddr.o \
......@@ -66,10 +62,6 @@ labcomm_fd_reader_writer.o : labcomm_fd_reader_writer.c labcomm_fd_reader_write
ethaddr.o: ethaddr.c
$(CREATED_DIRS):
mkdir -p $@
## NB! the tests need CUnit to be installed
run-test: $(TESTS:%=run-test-%)
run-test-%: $(TEST_DIR)/% | $(TEST_DIR)
......@@ -85,6 +77,8 @@ $(TEST_DIR)/%: $(TEST_DIR)/%.o
$(TEST_DIR)/gen:
mkdir -p $@
.PRECIOUS: $(TEST_DIR)/gen/%.c
.PRECIOUS: $(TEST_DIR)/gen/%.h
$(TEST_DIR)/gen/%.c $(TEST_DIR)/gen/%.h: $(TEST_DIR)/%.lc | $(TEST_DIR)/gen
$(LABCOMM) \
--c=$(TEST_DIR)/gen/$*.c \
......@@ -127,7 +121,7 @@ $(TEST_DIR)/test_labcomm_generated_encoding.o: labcomm_private.h
$(TEST_DIR)/test_labcomm_generated_encoding.o: $(TEST_DIR)/gen/generated_encoding.h
$(TEST_DIR)/test_labcomm_generated_encoding : $(TEST_DIR)/gen/generated_encoding.o
$(TEST_DIR)/test_labcomm: $(TEST_GEN_DIR)/test_sample.o
$(TEST_DIR)/test_labcomm: $(TEST_DIR)/gen/test_sample.o
$(TEST_DIR)/test_signature_numbers.c: $(TEST_DIR)/gen/another_encoding.h
$(TEST_DIR)/test_signature_numbers.c: $(TEST_DIR)/gen/generated_encoding.h
$(TEST_DIR)/test_signature_numbers: $(TEST_DIR)/gen/another_encoding.o
......
......@@ -83,11 +83,15 @@ void labcomm_decoder_free(struct labcomm_decoder* d)
labcomm_memory_free(memory, 0, d);
}
static void collect_flat_signature(
static int collect_flat_signature(
struct labcomm_decoder *decoder,
struct labcomm_writer *writer)
{
int type = labcomm_read_packed32(decoder->reader);
int result, type;
type = labcomm_read_packed32(decoder->reader);
result = decoder->reader->error;
if (result < 0) { goto out; }
if (type >= LABCOMM_USER) {
decoder->on_error(LABCOMM_ERROR_UNIMPLEMENTED_FUNC, 3,
"Implement %s ... (1) for type 0x%x\n", __FUNCTION__, type);
......@@ -103,7 +107,8 @@ static void collect_flat_signature(
int n = labcomm_read_packed32(decoder->reader);
labcomm_write_packed32(writer, n);
}
collect_flat_signature(decoder, writer);
result = collect_flat_signature(decoder, writer);
if (result < 0) { goto out; }
} break;
case LABCOMM_STRUCT: {
int fields, i;
......@@ -114,7 +119,8 @@ static void collect_flat_signature(
char *name = labcomm_read_string(decoder->reader);
labcomm_write_string(writer, name);
labcomm_memory_free(decoder->memory, 1, name);
collect_flat_signature(decoder, writer);
result = collect_flat_signature(decoder, writer);
if (result < 0) { goto out; }
}
} break;
case LABCOMM_BOOLEAN:
......@@ -127,11 +133,14 @@ static void collect_flat_signature(
case LABCOMM_STRING: {
} break;
default: {
result = -ENOSYS;
decoder->on_error(LABCOMM_ERROR_UNIMPLEMENTED_FUNC, 3,
"Implement %s (2) for type 0x%x...\n", __FUNCTION__, type);
} break;
}
}
out:
return result;
}
static int writer_ioctl(struct labcomm_writer *writer,
......@@ -181,7 +190,7 @@ static int decode_typedef_or_sample(struct labcomm_decoder *d, int kind)
local_index = 0;
labcomm_writer_alloc(&writer, writer.action_context, "");
labcomm_writer_start(&writer, writer.action_context, 0, NULL, NULL);
remote_index = labcomm_read_packed32(d->reader); //int
remote_index = labcomm_read_packed32(d->reader);
signature.name = labcomm_read_string(d->reader);
signature.type = kind;
collect_flat_signature(d, &writer);
......
......@@ -201,6 +201,9 @@ int labcomm_internal_decoder_ioctl(struct labcomm_decoder *decoder,
for (i = sizeof(type) - 1 ; i >= 0 ; i--) { \
if (r->pos >= r->count) { \
labcomm_reader_fill(r, r->action_context); \
if (r->error < 0) { \
return 0; \
} \
} \
((unsigned char*)(&result))[i] = r->data[r->pos]; \
r->pos++; \
......@@ -216,6 +219,9 @@ int labcomm_internal_decoder_ioctl(struct labcomm_decoder *decoder,
for (i = 0 ; i < sizeof(type) ; i++) { \
if (r->pos >= r->count) { \
labcomm_reader_fille(r, r->action_context); \
if (r->error < 0) { \
return 0; \
} \
} \
((unsigned char*)(&result))[i] = r->data[r->pos]; \
r->pos++; \
......@@ -259,19 +265,23 @@ out:
static inline char *labcomm_read_string(struct labcomm_reader *r)
{
char *result;
int length, i;
char *result = NULL;
int length, pos;
length = labcomm_read_packed32(r);
result = labcomm_memory_alloc(r->memory, 1, length + 1);
for (i = 0 ; i < length ; i++) {
for (pos = 0 ; pos < length ; pos++) {
if (r->pos >= r->count) {
labcomm_reader_fill(r, r->action_context);
if (r->error < 0) {
goto out;
}
}
result[i] = r->data[r->pos];
result[pos] = r->data[r->pos];
r->pos++;
}
result[length] = 0;
out:
result[pos] = 0;
return result;
}
......
/*
test_labcomm.c -- Various labcomm tests
#include "CUnit/Basic.h"
#include "CUnit/Console.h"
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include "labcomm_private.h"
#include "labcomm_default_error_handler.h"
#include "labcomm_default_memory.h"
#include "labcomm_default_scheduler.h"
#include "test/gen/test_sample.h"
static unsigned char buffer[512];
static int writer_alloc(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
char *labcomm_version)
{
w->data = buffer;
w->data_size = sizeof(buffer);
w->count = sizeof(buffer);
return 0;
}
static int writer_start(struct labcomm_writer *w,
struct labcomm_writer_action_context *action_context,
int index, struct labcomm_signature *signature,
void *value)
{
return 0;
}
const struct labcomm_writer_action writer_action = {
.alloc = writer_alloc,
.start = writer_start,
};
static struct labcomm_writer_action_context writer_action_context = {
.next = NULL,
.action = &writer_action,
.context = NULL
};
static struct labcomm_writer writer = {
.action_context = &writer_action_context,
.data = buffer,
.data_size = sizeof(buffer),
.count = sizeof(buffer),
.pos = 0,
.error = 0,
};
static int reader_alloc(struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context,
char *labcomm_version)
{
r->data = buffer;
r->data_size = sizeof(buffer);
r->count = 0;
r->memory = labcomm_default_memory;
return 0;
}
static int reader_fill(struct labcomm_reader *r,
struct labcomm_reader_action_context *action_context)
{
r->error = -ENOMEM;
return r->error;
}
const struct labcomm_reader_action reader_action = {
.alloc = reader_alloc,
.fill = reader_fill,
};
static struct labcomm_reader_action_context reader_action_context = {
.next = NULL,
.action = &reader_action,
.context = NULL
};
static struct labcomm_reader reader = {
.action_context = &reader_action_context,
.data = buffer,
.data_size = sizeof(buffer),
.count = 0,
.pos = 0,
.error = 0,
};
test_sample_test_var encoder_var, decoder_var;
void handle_test_var(test_sample_test_var *v, void *ctx)
{
decoder_var = *v;
}
int test_decode_one(struct labcomm_decoder *decoder)
{
int result;
for (reader.count = 0 ; reader.count < writer.pos ; reader.count++) {
reader.error = 0;
reader.pos = 0;
result = labcomm_decoder_decode_one(decoder);
if (result >= 0) {
fprintf(stderr, "Got result from buffer with bogus length (%d)\n",
result);
exit(1);
}
}
reader.error = 0;
reader.pos = 0;
reader.count = writer.pos;
result = labcomm_decoder_decode_one(decoder);
if (result < 0) {
fprintf(stderr, "Got result from buffer with correct length (%d)\n",
result);
exit(1);
}
return result;
}
int main(void)
{
int err;
struct labcomm_encoder *encoder = labcomm_encoder_new(
&writer,
labcomm_default_error_handler,
labcomm_default_memory,
labcomm_default_scheduler);
struct labcomm_decoder *decoder = labcomm_decoder_new(
&reader,
labcomm_default_error_handler,
labcomm_default_memory,
labcomm_default_scheduler);
labcomm_decoder_register_test_sample_test_var(decoder,
handle_test_var,
NULL);
labcomm_encoder_register_test_sample_test_var(encoder);
err = test_decode_one(decoder);
fprintf(stderr, "decode of register %d\n", err);
writer.pos = 0;
encoder_var = 314;
labcomm_encode_test_sample_test_var(encoder, &encoder_var);
err = test_decode_one(decoder);
fprintf(stderr, "decode of sample %d -> %d\n", err, decoder_var);
if (decoder_var != encoder_var) {
fprintf(stderr, "Failed to decode correct value %d != %d\n",
encoder_var, decoder_var);
exit(1);
}
return 0;
}
#if 0
#include <stdbool.h>
#include <stdlib.h>
......@@ -186,3 +353,4 @@ int main()
return CU_get_error();
}
#endif
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment