protobuf-generate 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4dfc74f7688e44e7b50a3ce841ac809205633097
-  data.tar.gz: 9ba9103b05c1a65409d0b9503838f575158be164
+  metadata.gz: 1ea129566e0b2ad5679577e43688ced171c37a36
+  data.tar.gz: 828412c95f275bd17948cbe373f079e09156c960
 SHA512:
-  metadata.gz: 505001be4621794ff21a622971c6c6a1de00c094cffed065572fc34c3c55f62e8c88c9f8cf8370abe79a10c27363ee4398e44be9ad35c7ced92cf216eb737575
-  data.tar.gz: 0fe4e63e11eca9882642e30ca3a401fcd5b772b7e3d20b11b7b8f5c109ba3d9a2e95cbd512b8b16cdeddcd93e77d7135c64771a947749cbdacd264e1d0f6c5c8
+  metadata.gz: 11392a315c361807a57116c3fc8e2c6707fe1e2c65b8009f82aeb48eda199d6b88cad8bf4ef67aada115ae8ca8af18bed37dc0416db512b4f7368bb9f1c40960
+  data.tar.gz: fd9553ff5266584892cf54a8cbdf4da1a040cb626c86df9d6afffa18e97760a6d04d7fa1dcba141b9595a59213ca6843a36b8af1f67795840e8497bd5141475b

data/lib/protobuf/generate/language/c/c.erb

@@ -239,6 +239,10 @@ static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
 
   offset = read_raw_byte(&b, buffer, offset);
   *tag |= (uint64_t)(b & 0x7f) << 56;
+  if ((b & 0x80) == 0) return offset;
+
+  offset = read_raw_byte(&b, buffer, offset);
+  *tag |= (uint64_t)(b & 0x7f) << 63;
   return offset;
 }
 <% end %>
@@ -478,7 +482,7 @@ static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
         {
           uint64_t value = 0;
           offset = read_raw_varint64(&value, buffer, offset);
-          pb-><%= field.name %> = (int64_t)tag;
+          pb-><%= field.name %> = (int64_t)value;
         }
         <% elsif field.type == 'sint32' %>
           offset = read_raw_varint32(&tag, buffer, offset);
@@ -525,7 +529,7 @@ static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
           for (size_t i = 0; i < (size_t)tag; ++i)
             offset = read_raw_byte((pb-><%= field.name %>.data + i), buffer, offset);
         <% end %>
-          break;
+        break;
       <% end %>
       }
     }

data/protobuf-generate.gemspec

@@ -2,7 +2,7 @@ $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
 spec = Gem::Specification.new do |s|
   s.name        = 'protobuf-generate'
-  s.version     = '0.2.2'
+  s.version     = '0.2.3'
   s.summary     = 'A multi-language concrete protobuf code generator.'
   s.description = 'A simple PEG parser, AST and template based approach to code generation.'
   s.authors     = ['Shane Hanna']

data/test/c99/.gitignore

@@ -0,0 +1,2 @@
+alltypes.[ch]
+test

data/test/c99/alltypes.proto

@@ -0,0 +1,82 @@
+// Wiretype 0, Varint.
+
+message ProtoInt32 {
+  required int32 value = 1;
+}
+
+message ProtoInt64 {
+  required int64 value = 1;
+}
+
+message ProtoUint32 {
+  required uint32 value = 1;
+}
+
+message ProtoUint64 {
+  required uint64 value = 1;
+}
+
+message ProtoSint32 {
+  required sint32 value = 1;
+}
+
+message ProtoSint64 {
+  required sint64 value = 1;
+}
+
+message ProtoBool {
+  required bool value = 1;
+}
+
+enum ProtoEnumType {
+  One        = 1;
+  Two        = 2;
+  Three      = 3;
+  Four       = 4;
+  NinetyNine = 99;
+}
+
+message ProtoEnum {
+  required ProtoEnumType value = 1;
+}
+
+// Wiretype 1, 64-bit.
+
+message ProtoFixed64 {
+  required fixed64 value = 1;
+}
+
+message ProtoSfixed64 {
+  required sfixed64 value = 1;
+}
+
+message ProtoDouble {
+  required double value = 1;
+}
+
+
+// Wiretype 2, Length-delimited.
+
+message ProtoString {
+  required string value = 1; // @size = 32
+}
+
+message ProtoBytes {
+  required string value = 1; // @size = 32
+}
+
+
+// Wiretype 5, 32-bit.
+
+message ProtoFixed32 {
+  required fixed32 value = 1;
+}
+
+message ProtoSfixed32 {
+  required sfixed32 value = 1;
+}
+
+message ProtoFloat {
+  required float value = 1;
+}
+

data/test/c99/makefile

@@ -0,0 +1,15 @@
+CFLAGS := -g -Wall -Werror -std=c11
+
+all: test
+
+protobufs:
+	bundle exec ../../bin/protobuf-generate c99 alltypes.proto
+
+test: protobufs test.c alltypes.c
+	$(CC) $(CFLAGS) -o $@ test.c alltypes.c
+	./test
+
+clean:
+	rm -f test
+
+real-clean: clean

data/test/c99/test.c

@@ -0,0 +1,242 @@
+#include "alltypes.h"
+#include "unit.h"
+
+#include <float.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+#define xstr(s) str(s)
+#define str(s)  #s
+
+#define assert_encode_decode(name, io_value, message) \
+  do { \
+    size_t  size; \
+    uint8_t buffer[256]; \
+    name ## _t in = {io_value}; \
+    name ## _t io = {io_value}; \
+    name ## _encode(&io, buffer, sizeof(buffer), &size); \
+    name ## _decode(&io, buffer, size, &size); \
+    unit_assert(memcmp(&io.value, &in.value, sizeof(in.value)) == 0, "encode decode " message); \
+  } while (0)
+
+static char *test_int32() {
+  assert_encode_decode(proto_int32, 0,         "int32  1 byte value 0");
+  assert_encode_decode(proto_int32, 1,         "int32  1 byte value 1");
+  assert_encode_decode(proto_int32, 1234,      "int32  2 byte value 1234");
+  assert_encode_decode(proto_int32, 123456,    "int32  3 byte value 123456");
+  assert_encode_decode(proto_int32, 12345678,  "int32  4 byte value 12345678");
+  assert_encode_decode(proto_int32, INT32_MAX, "int32  5 byte value " xstr(INT32_MAX));
+
+  assert_encode_decode(proto_int32, -1,        "int32 10 byte value -1");
+  assert_encode_decode(proto_int32, -1234,     "int32 10 byte value -1234");
+  assert_encode_decode(proto_int32, -123456,   "int32 10 byte value -123456");
+  assert_encode_decode(proto_int32, -12345678, "int32 10 byte value -12345678");
+  assert_encode_decode(proto_int32, INT32_MIN, "int32 10 byte value " xstr(INT32_MIN));
+  return 0;
+}
+
+static char *test_int64() {
+  assert_encode_decode(proto_int64, 0,         "int64  1 byte value 0");
+  assert_encode_decode(proto_int64, 1,         "int64  1 byte value 1");
+  assert_encode_decode(proto_int64, 1234,      "int64  2 byte value 1234");
+  assert_encode_decode(proto_int64, 123456,    "int64  3 byte value 123456");
+  assert_encode_decode(proto_int64, 12345678,  "int64  4 byte value 12345678");
+  assert_encode_decode(proto_int64, INT64_MAX, "int64 10 byte value " xstr(INT64_MAX));
+
+  assert_encode_decode(proto_int64, -1,        "int64 10 byte value -1");
+  assert_encode_decode(proto_int64, -1234,     "int64 10 byte value -1234");
+  assert_encode_decode(proto_int64, -123456,   "int64 10 byte value -123456");
+  assert_encode_decode(proto_int64, -12345678, "int64 10 byte value -12345678");
+  assert_encode_decode(proto_int64, INT64_MIN, "int64 10 byte value " xstr(INT64_MIN));
+  return 0;
+}
+
+static char *test_uint32() {
+  assert_encode_decode(proto_uint32, 0,          "uint32 1 byte value 0");
+  assert_encode_decode(proto_uint32, 1,          "uint32 1 byte value 1");
+  assert_encode_decode(proto_uint32, 1,          "uint32 1 byte value 1");
+  assert_encode_decode(proto_uint32, UINT32_MAX, "uint32 5 byte value " xstr(UINT32_MAX));
+  return 0;
+}
+
+static char *test_uint64() {
+  assert_encode_decode(proto_uint64, 0,          "uint64  1 byte value 0");
+  assert_encode_decode(proto_uint64, 1,          "uint64  1 byte value 1");
+  assert_encode_decode(proto_uint64, 1,          "uint64  1 byte value 1");
+  assert_encode_decode(proto_uint64, UINT64_MAX, "uint64 10 byte value " xstr(UINT64_MAX));
+  return 0;
+}
+
+static char *test_sint32() {
+  assert_encode_decode(proto_sint32, 0,         "sint32  1 byte value 0");
+  assert_encode_decode(proto_sint32, 1,         "sint32  1 byte value 1");
+  assert_encode_decode(proto_sint32, 1234,      "sint32  2 byte value 1234");
+  assert_encode_decode(proto_sint32, 123456,    "sint32  3 byte value 123456");
+  assert_encode_decode(proto_sint32, 12345678,  "sint32  4 byte value 12345678");
+  assert_encode_decode(proto_sint32, INT32_MAX, "sint32  5 byte value " xstr(INT32_MAX));
+
+  assert_encode_decode(proto_sint32, -1,        "sint32 10 byte value -1");
+  assert_encode_decode(proto_sint32, -1234,     "sint32 10 byte value -1234");
+  assert_encode_decode(proto_sint32, -123456,   "sint32 10 byte value -123456");
+  assert_encode_decode(proto_sint32, -12345678, "sint32 10 byte value -12345678");
+  assert_encode_decode(proto_sint32, INT32_MIN, "sint32 10 byte value " xstr(INT32_MIN));
+  return 0;
+}
+
+static char *test_sint64() {
+  assert_encode_decode(proto_sint64, 0,         "sint64 value 0");
+  assert_encode_decode(proto_sint64, 1,         "sint64 value 1");
+  assert_encode_decode(proto_sint64, 1234,      "sint64 value 1234");
+  assert_encode_decode(proto_sint64, 123456,    "sint64 value 123456");
+  assert_encode_decode(proto_sint64, 12345678,  "sint64 value 12345678");
+  assert_encode_decode(proto_sint64, INT64_MAX, "sint32 value " xstr(INT64_MAX));
+
+  assert_encode_decode(proto_sint64, -1,        "sint64 value -1");
+  assert_encode_decode(proto_sint64, -1234,     "sint64 value -1234");
+  assert_encode_decode(proto_sint64, -123456,   "sint64 value -123456");
+  assert_encode_decode(proto_sint64, -12345678, "sint64 value -12345678");
+  assert_encode_decode(proto_sint64, INT64_MIN, "sint64 value " xstr(INT64_MIN));
+  return 0;
+}
+
+static char *test_bool() {
+  assert_encode_decode(proto_bool, true,  "bool value true");
+  assert_encode_decode(proto_bool, false, "bool value false");
+  assert_encode_decode(proto_bool, 1,     "bool value 1");
+  assert_encode_decode(proto_bool, 0,     "bool value 0");
+  return 0;
+}
+
+static char *test_enum() {
+  assert_encode_decode(proto_enum, PROTO_ENUM_TYPE_ONE,         "enum value " str(PROTO_ENUM_TYPE_ONE));
+  assert_encode_decode(proto_enum, PROTO_ENUM_TYPE_TWO,         "enum value " str(PROTO_ENUM_TYPE_TWO));
+  assert_encode_decode(proto_enum, PROTO_ENUM_TYPE_NINETY_NINE, "enum value " str(PROTO_ENUM_TYPE_NINETY_NINE));
+  return 0;
+}
+
+static char *test_fixed64() {
+  assert_encode_decode(proto_fixed64, 0,          "fixed64  1 byte value 0");
+  assert_encode_decode(proto_fixed64, 1,          "fixed64  1 byte value 1");
+  assert_encode_decode(proto_fixed64, 1,          "fixed64  1 byte value 1");
+  assert_encode_decode(proto_fixed64, UINT64_MAX, "fixed64 10 byte value " xstr(UINT64_MAX));
+  return 0;
+}
+
+static char *test_sfixed64() {
+  assert_encode_decode(proto_sfixed64, 0,         "sfixed64 value 0");
+  assert_encode_decode(proto_sfixed64, 1,         "sfixed64 value 1");
+  assert_encode_decode(proto_sfixed64, 1234,      "sfixed64 value 1234");
+  assert_encode_decode(proto_sfixed64, 123456,    "sfixed64 value 123456");
+  assert_encode_decode(proto_sfixed64, 12345678,  "sfixed64 value 12345678");
+  assert_encode_decode(proto_sfixed64, INT64_MAX, "sfixed32 value " xstr(INT64_MAX));
+
+  assert_encode_decode(proto_sfixed64, -1,        "sfixed64 value -1");
+  assert_encode_decode(proto_sfixed64, -1234,     "sfixed64 value -1234");
+  assert_encode_decode(proto_sfixed64, -123456,   "sfixed64 value -123456");
+  assert_encode_decode(proto_sfixed64, -12345678, "sfixed64 value -12345678");
+  assert_encode_decode(proto_sfixed64, INT64_MIN, "sfixed64 value " xstr(INT64_MIN));
+  return 0;
+}
+
+static char *test_double() {
+  assert_encode_decode(proto_double, DBL_MAX, "double value " xstr(DBL_MAX));
+  assert_encode_decode(proto_double, DBL_MIN, "double value " xstr(DBL_MIN));
+  return 0;
+}
+
+static char *test_string() {
+  size_t  size;
+  uint8_t buffer[256];
+
+  proto_string_t io;
+  proto_string_t in;
+  strcpy((char *)in.value.data, "test");
+  in.value.size = 5;
+
+  proto_string_encode(&in, buffer, sizeof(buffer), &size);
+  proto_string_decode(&io, buffer, size, &size);
+
+  unit_assert((io.value.size == in.value.size),                           "encode decode string size 5");
+  unit_assert(memcmp(&io.value.data, &in.value.data, in.value.size) == 0, "encode decode string \"test\"");
+  return 0;
+}
+
+static char *test_bytes() {
+  size_t  size;
+  uint8_t buffer[256];
+
+  proto_bytes_t io;
+  proto_bytes_t in;
+  memcpy(in.value.data, "test", 4);
+  in.value.size = 4;
+
+  proto_bytes_encode(&in, buffer, sizeof(buffer), &size);
+  proto_bytes_decode(&io, buffer, size, &size);
+
+  unit_assert((io.value.size == in.value.size),                           "encode decode bytes size 4");
+  unit_assert(memcmp(&io.value.data, &in.value.data, in.value.size) == 0, "encode decode bytes \"test\"");
+  return 0;
+}
+
+static char *test_fixed32() {
+  assert_encode_decode(proto_fixed32, 0,          "fixed32  1 byte value 0");
+  assert_encode_decode(proto_fixed32, 1,          "fixed32  1 byte value 1");
+  assert_encode_decode(proto_fixed32, 1,          "fixed32  1 byte value 1");
+  assert_encode_decode(proto_fixed32, UINT32_MAX, "fixed32 10 byte value " xstr(UINT32_MAX));
+  return 0;
+}
+
+static char *test_sfixed32() {
+  assert_encode_decode(proto_sfixed32, 0,         "sfixed32 value 0");
+  assert_encode_decode(proto_sfixed32, 1,         "sfixed32 value 1");
+  assert_encode_decode(proto_sfixed32, 1234,      "sfixed32 value 1234");
+  assert_encode_decode(proto_sfixed32, 123456,    "sfixed32 value 123456");
+  assert_encode_decode(proto_sfixed32, 12345678,  "sfixed32 value 12345678");
+  assert_encode_decode(proto_sfixed32, INT32_MAX, "sfixed32 value " xstr(INT32_MAX));
+
+  assert_encode_decode(proto_sfixed32, -1,        "sfixed32 value -1");
+  assert_encode_decode(proto_sfixed32, -1234,     "sfixed32 value -1234");
+  assert_encode_decode(proto_sfixed32, -123456,   "sfixed32 value -123456");
+  assert_encode_decode(proto_sfixed32, -12345678, "sfixed32 value -12345678");
+  assert_encode_decode(proto_sfixed32, INT32_MIN, "sfixed32 value " xstr(INT32_MIN));
+  return 0;
+}
+
+static char *test_float() {
+  assert_encode_decode(proto_float, FLT_MAX, "float value " xstr(FLT_MAX));
+  assert_encode_decode(proto_float, FLT_MIN, "float value " xstr(FLT_MIN));
+  return 0;
+}
+
+static char *test_all() {
+  unit_run(test_int32);
+  unit_run(test_int64);
+  unit_run(test_uint32);
+  unit_run(test_uint64);
+  unit_run(test_sint32);
+  unit_run(test_sint64);
+  unit_run(test_bool);
+  unit_run(test_enum);
+  unit_run(test_fixed64);
+  unit_run(test_sfixed64);
+  unit_run(test_double);
+  unit_run(test_string);
+  unit_run(test_bytes);
+  unit_run(test_fixed32);
+  unit_run(test_sfixed32);
+  unit_run(test_float);
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  char *result = test_all();
+  printf("tests:      %u\n", unit_tests);
+  printf("assertions: %u\n", unit_assertions);
+
+  if (result != 0) printf("failed:     %s\n", result);
+  else printf("passed:     all\n");
+
+  return result != 0;
+}

data/test/c99/unit.h

@@ -0,0 +1,25 @@
+/*
+  Mini Unit
+
+  Shamelessly taken and tweaked to taste from
+  http://www.jera.com/techinfo/jtns/jtn002.html
+*/
+
+#pragma once
+
+static unsigned int unit_tests      = 0;
+static unsigned int unit_assertions = 0;
+
+#define unit_assert(test, message) \
+  do { \
+    unit_assertions++; \
+    if (!(test)) return message; \
+  } while (0)
+
+#define unit_run(test) \
+  do { \
+    unit_tests++; \
+    char *message = test(); \
+    if (message) return message; \
+  } while (0)
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-generate
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Shane Hanna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-28 00:00:00.000000000 Z
+date: 2013-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -58,6 +58,11 @@ files:
 - lib/protobuf/generate/language/c/h.erb
 - lib/protobuf/generate/parser.rb
 - protobuf-generate.gemspec
+- test/c99/.gitignore
+- test/c99/alltypes.proto
+- test/c99/makefile
+- test/c99/test.c
+- test/c99/unit.h
 homepage: https://bitbucket.org/shanehanna/protobuf-generate
 licenses:
 - MIT
@@ -82,4 +87,9 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A multi-language concrete protobuf code generator.
-test_files: []
+test_files:
+- test/c99/.gitignore
+- test/c99/alltypes.proto
+- test/c99/makefile
+- test/c99/test.c
+- test/c99/unit.h