Rewrite tests/example-test.cpp to use addressbook example from capnproto C++ project.

Makefile.am

@@ -63,19 +63,19 @@ capn_test_SOURCES = \
 	tests/capn-test.cpp \
 	tests/capn-stream-test.cpp \
 	tests/example-test.cpp \
-	tests/example.capnp.c \
+	tests/addressbook.capnp.c \
 	compiler/test.capnp.c \
 	compiler/schema-test.cpp \
 	compiler/schema.capnp.c
 noinst_HEADERS += \
 	compiler/test.capnp.h \
-	tests/example.capnp.h
+	tests/addressbook.capnp.h
 EXTRA_DIST += \
 	compiler/c.capnp \
 	compiler/c++.capnp \
 	compiler/schema.capnp \
 	compiler/test.capnp \
-	tests/example.capnp
+	tests/addressbook.capnp
 capn_test_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_CPPFLAGS)
 capn_test_CXXFLAGS = -std=gnu++11 -pthread
 capn_test_LDADD = libcapnp_c.la $(GTEST_LDADD)

README.md

@@ -58,7 +58,9 @@ struct MyStruct {}
 
 ### Example C code
 
-See the unit tests in [`tests/example-test.cpp`](tests/example-test.cpp). The example schema file is [`tests/example.capnp`](tests/example.capnp). The tests are written in C++, but only use C features.
+See the unit tests in [`tests/example-test.cpp`](tests/example-test.cpp).
+The example schema file is [`tests/addressbook.capnp`](tests/addressbook.capnp).
+The tests are written in C++, but only use C features.
 
 You need to compile these runtime library files and link them into your own project's binaries:
 
@@ -66,7 +68,9 @@ You need to compile these runtime library files and link them into your own proj
 * [`lib/capn-malloc.c`](lib/capn-malloc.c)
 * [`lib/capn-stream.c`](lib/capn-stream.c)
 
-Your include path must contain the runtime library directory [`lib`](lib). Header file [`lib/capnp_c.h`](lib/capnp_c.h) contains the public interfaces of the library.
+Your include path must contain the runtime library directory
+[`lib`](lib). Header file [`lib/capnp_c.h`](lib/capnp_c.h) contains
+the public interfaces of the library.
 
 Using make-based builds, make may try to compile `${x}.capnp` from
 `${x}.capnp.c` using its built-in rule for compiling `${y}` from

tests/addressbook.capnp

@@ -0,0 +1,58 @@
+# From https://github.com/sandstorm-io/capnproto/blob/6816634a08b08bc8f52b4ee809afb58389f19655/c%2B%2B/samples/addressbook.capnp
+#
+# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
+# Licensed under the MIT License:
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+@0x9eb32e19f86ee174;
+
+using C = import "/c.capnp";
+$C.fieldgetset;
+
+struct Person {
+  id @0 :UInt32;
+  name @1 :Text;
+  email @2 :Text;
+  phones @3 :List(PhoneNumber);
+
+  struct PhoneNumber {
+    number @0 :Text;
+    type @1 :Type;
+
+    enum Type {
+      mobile @0;
+      home @1;
+      work @2;
+    }
+  }
+
+  employment :union {
+    unemployed @4 :Void;
+    employer @5 :Text;
+    school @6 :Text;
+    selfEmployed @7 :Void;
+    # We assume that a person is only one of these.
+  }
+}
+
+struct AddressBook {
+  people @0 :List(Person);
+}
+

tests/addressbook.capnp.c

@@ -0,0 +1,200 @@
+#include "addressbook.capnp.h"
+/* AUTO GENERATED - DO NOT EDIT */
+static const capn_text capn_val0 = {0,"",0};
+
+Person_ptr new_Person(struct capn_segment *s) {
+	Person_ptr p;
+	p.p = capn_new_struct(s, 8, 4);
+	return p;
+}
+Person_list new_Person_list(struct capn_segment *s, int len) {
+	Person_list p;
+	p.p = capn_new_list(s, len, 8, 4);
+	return p;
+}
+void read_Person(struct Person *s, Person_ptr p) {
+	capn_resolve(&p.p);
+	s->id = capn_read32(p.p, 0);
+	s->name = capn_get_text(p.p, 0, capn_val0);
+	s->email = capn_get_text(p.p, 1, capn_val0);
+	s->phones.p = capn_getp(p.p, 2, 0);
+	s->employment_which = (enum Person_employment_which)(int) capn_read16(p.p, 4);
+	switch (s->employment_which) {
+	case Person_employment_employer:
+	case Person_employment_school:
+		s->employment.school = capn_get_text(p.p, 3, capn_val0);
+		break;
+	default:
+		break;
+	}
+}
+void write_Person(const struct Person *s, Person_ptr p) {
+	capn_resolve(&p.p);
+	capn_write32(p.p, 0, s->id);
+	capn_set_text(p.p, 0, s->name);
+	capn_set_text(p.p, 1, s->email);
+	capn_setp(p.p, 2, s->phones.p);
+	capn_write16(p.p, 4, s->employment_which);
+	switch (s->employment_which) {
+	case Person_employment_employer:
+	case Person_employment_school:
+		capn_set_text(p.p, 3, s->employment.school);
+		break;
+	default:
+		break;
+	}
+}
+void get_Person(struct Person *s, Person_list l, int i) {
+	Person_ptr p;
+	p.p = capn_getp(l.p, i, 0);
+	read_Person(s, p);
+}
+void set_Person(const struct Person *s, Person_list l, int i) {
+	Person_ptr p;
+	p.p = capn_getp(l.p, i, 0);
+	write_Person(s, p);
+}
+
+uint32_t Person_get_id(Person_ptr p)
+{
+	uint32_t id;
+	id = capn_read32(p.p, 0);
+	return id;
+}
+
+capn_text Person_get_name(Person_ptr p)
+{
+	capn_text name;
+	name = capn_get_text(p.p, 0, capn_val0);
+	return name;
+}
+
+capn_text Person_get_email(Person_ptr p)
+{
+	capn_text email;
+	email = capn_get_text(p.p, 1, capn_val0);
+	return email;
+}
+
+Person_PhoneNumber_list Person_get_phones(Person_ptr p)
+{
+	Person_PhoneNumber_list phones;
+	phones.p = capn_getp(p.p, 2, 0);
+	return phones;
+}
+
+void Person_set_id(Person_ptr p, uint32_t id)
+{
+	capn_write32(p.p, 0, id);
+}
+
+void Person_set_name(Person_ptr p, capn_text name)
+{
+	capn_set_text(p.p, 0, name);
+}
+
+void Person_set_email(Person_ptr p, capn_text email)
+{
+	capn_set_text(p.p, 1, email);
+}
+
+void Person_set_phones(Person_ptr p, Person_PhoneNumber_list phones)
+{
+	capn_setp(p.p, 2, phones.p);
+}
+
+Person_PhoneNumber_ptr new_Person_PhoneNumber(struct capn_segment *s) {
+	Person_PhoneNumber_ptr p;
+	p.p = capn_new_struct(s, 8, 1);
+	return p;
+}
+Person_PhoneNumber_list new_Person_PhoneNumber_list(struct capn_segment *s, int len) {
+	Person_PhoneNumber_list p;
+	p.p = capn_new_list(s, len, 8, 1);
+	return p;
+}
+void read_Person_PhoneNumber(struct Person_PhoneNumber *s, Person_PhoneNumber_ptr p) {
+	capn_resolve(&p.p);
+	s->number = capn_get_text(p.p, 0, capn_val0);
+	s->type = (enum Person_PhoneNumber_Type)(int) capn_read16(p.p, 0);
+}
+void write_Person_PhoneNumber(const struct Person_PhoneNumber *s, Person_PhoneNumber_ptr p) {
+	capn_resolve(&p.p);
+	capn_set_text(p.p, 0, s->number);
+	capn_write16(p.p, 0, (uint16_t) (s->type));
+}
+void get_Person_PhoneNumber(struct Person_PhoneNumber *s, Person_PhoneNumber_list l, int i) {
+	Person_PhoneNumber_ptr p;
+	p.p = capn_getp(l.p, i, 0);
+	read_Person_PhoneNumber(s, p);
+}
+void set_Person_PhoneNumber(const struct Person_PhoneNumber *s, Person_PhoneNumber_list l, int i) {
+	Person_PhoneNumber_ptr p;
+	p.p = capn_getp(l.p, i, 0);
+	write_Person_PhoneNumber(s, p);
+}
+
+capn_text Person_PhoneNumber_get_number(Person_PhoneNumber_ptr p)
+{
+	capn_text number;
+	number = capn_get_text(p.p, 0, capn_val0);
+	return number;
+}
+
+enum Person_PhoneNumber_Type Person_PhoneNumber_get_type(Person_PhoneNumber_ptr p)
+{
+	enum Person_PhoneNumber_Type type;
+	type = (enum Person_PhoneNumber_Type)(int) capn_read16(p.p, 0);
+	return type;
+}
+
+void Person_PhoneNumber_set_number(Person_PhoneNumber_ptr p, capn_text number)
+{
+	capn_set_text(p.p, 0, number);
+}
+
+void Person_PhoneNumber_set_type(Person_PhoneNumber_ptr p, enum Person_PhoneNumber_Type type)
+{
+	capn_write16(p.p, 0, (uint16_t) (type));
+}
+
+AddressBook_ptr new_AddressBook(struct capn_segment *s) {
+	AddressBook_ptr p;
+	p.p = capn_new_struct(s, 0, 1);
+	return p;
+}
+AddressBook_list new_AddressBook_list(struct capn_segment *s, int len) {
+	AddressBook_list p;
+	p.p = capn_new_list(s, len, 0, 1);
+	return p;
+}
+void read_AddressBook(struct AddressBook *s, AddressBook_ptr p) {
+	capn_resolve(&p.p);
+	s->people.p = capn_getp(p.p, 0, 0);
+}
+void write_AddressBook(const struct AddressBook *s, AddressBook_ptr p) {
+	capn_resolve(&p.p);
+	capn_setp(p.p, 0, s->people.p);
+}
+void get_AddressBook(struct AddressBook *s, AddressBook_list l, int i) {
+	AddressBook_ptr p;
+	p.p = capn_getp(l.p, i, 0);
+	read_AddressBook(s, p);
+}
+void set_AddressBook(const struct AddressBook *s, AddressBook_list l, int i) {
+	AddressBook_ptr p;
+	p.p = capn_getp(l.p, i, 0);
+	write_AddressBook(s, p);
+}
+
+Person_list AddressBook_get_people(AddressBook_ptr p)
+{
+	Person_list people;
+	people.p = capn_getp(p.p, 0, 0);
+	return people;
+}
+
+void AddressBook_set_people(AddressBook_ptr p, Person_list people)
+{
+	capn_setp(p.p, 0, people.p);
+}

tests/addressbook.capnp.h

@@ -0,0 +1,134 @@
+#ifndef CAPN_9EB32E19F86EE174
+#define CAPN_9EB32E19F86EE174
+/* AUTO GENERATED - DO NOT EDIT */
+#include <capnp_c.h>
+
+#if CAPN_VERSION != 1
+#error "version mismatch between capnp_c.h and generated code"
+#endif
+
+#include "c.capnp.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct Person;
+struct Person_PhoneNumber;
+struct AddressBook;
+
+typedef struct {capn_ptr p;} Person_ptr;
+typedef struct {capn_ptr p;} Person_PhoneNumber_ptr;
+typedef struct {capn_ptr p;} AddressBook_ptr;
+
+typedef struct {capn_ptr p;} Person_list;
+typedef struct {capn_ptr p;} Person_PhoneNumber_list;
+typedef struct {capn_ptr p;} AddressBook_list;
+
+enum Person_PhoneNumber_Type {
+	Person_PhoneNumber_Type_mobile = 0,
+	Person_PhoneNumber_Type_home = 1,
+	Person_PhoneNumber_Type_work = 2
+};
+enum Person_employment_which {
+	Person_employment_unemployed = 0,
+	Person_employment_employer = 1,
+	Person_employment_school = 2,
+	Person_employment_selfEmployed = 3
+};
+
+struct Person {
+	uint32_t id;
+	capn_text name;
+	capn_text email;
+	Person_PhoneNumber_list phones;
+	enum Person_employment_which employment_which;
+	union {
+		capn_text employer;
+		capn_text school;
+	} employment;
+};
+
+static const size_t Person_word_count = 1;
+
+static const size_t Person_pointer_count = 4;
+
+static const size_t Person_struct_bytes_count = 40;
+
+uint32_t Person_get_id(Person_ptr p);
+
+capn_text Person_get_name(Person_ptr p);
+
+capn_text Person_get_email(Person_ptr p);
+
+Person_PhoneNumber_list Person_get_phones(Person_ptr p);
+
+void Person_set_id(Person_ptr p, uint32_t id);
+
+void Person_set_name(Person_ptr p, capn_text name);
+
+void Person_set_email(Person_ptr p, capn_text email);
+
+void Person_set_phones(Person_ptr p, Person_PhoneNumber_list phones);
+
+struct Person_PhoneNumber {
+	capn_text number;
+	enum Person_PhoneNumber_Type type;
+};
+
+static const size_t Person_PhoneNumber_word_count = 1;
+
+static const size_t Person_PhoneNumber_pointer_count = 1;
+
+static const size_t Person_PhoneNumber_struct_bytes_count = 16;
+
+capn_text Person_PhoneNumber_get_number(Person_PhoneNumber_ptr p);
+
+enum Person_PhoneNumber_Type Person_PhoneNumber_get_type(Person_PhoneNumber_ptr p);
+
+void Person_PhoneNumber_set_number(Person_PhoneNumber_ptr p, capn_text number);
+
+void Person_PhoneNumber_set_type(Person_PhoneNumber_ptr p, enum Person_PhoneNumber_Type type);
+
+struct AddressBook {
+	Person_list people;
+};
+
+static const size_t AddressBook_word_count = 0;
+
+static const size_t AddressBook_pointer_count = 1;
+
+static const size_t AddressBook_struct_bytes_count = 8;
+
+Person_list AddressBook_get_people(AddressBook_ptr p);
+
+void AddressBook_set_people(AddressBook_ptr p, Person_list people);
+
+Person_ptr new_Person(struct capn_segment*);
+Person_PhoneNumber_ptr new_Person_PhoneNumber(struct capn_segment*);
+AddressBook_ptr new_AddressBook(struct capn_segment*);
+
+Person_list new_Person_list(struct capn_segment*, int len);
+Person_PhoneNumber_list new_Person_PhoneNumber_list(struct capn_segment*, int len);
+AddressBook_list new_AddressBook_list(struct capn_segment*, int len);
+
+void read_Person(struct Person*, Person_ptr);
+void read_Person_PhoneNumber(struct Person_PhoneNumber*, Person_PhoneNumber_ptr);
+void read_AddressBook(struct AddressBook*, AddressBook_ptr);
+
+void write_Person(const struct Person*, Person_ptr);
+void write_Person_PhoneNumber(const struct Person_PhoneNumber*, Person_PhoneNumber_ptr);
+void write_AddressBook(const struct AddressBook*, AddressBook_ptr);
+
+void get_Person(struct Person*, Person_list, int i);
+void get_Person_PhoneNumber(struct Person_PhoneNumber*, Person_PhoneNumber_list, int i);
+void get_AddressBook(struct AddressBook*, AddressBook_list, int i);
+
+void set_Person(const struct Person*, Person_list, int i);
+void set_Person_PhoneNumber(const struct Person_PhoneNumber*, Person_PhoneNumber_list, int i);
+void set_AddressBook(const struct AddressBook*, AddressBook_list, int i);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

tests/example-test.cpp

@@ -12,34 +12,63 @@
 #include <cstdint>
 
 #include "capnp_c.h"
-#include "example.capnp.h"
+#include "addressbook.capnp.h"
 
-TEST(Examples, RoundTrip) {
+static capn_text chars_to_text(const char *chars) {
+  return (capn_text) {
+    .len = (int) strlen(chars),
+    .str = chars,
+    .seg = NULL,
+  };
+}
+
+// EXPECT_CAPN_TEXT_EQ arguments:
+//   const char * expected
+//   capn_text t
+#define EXPECT_CAPN_TEXT_EQ(expected, t) \
+  do {                                                  \
+    EXPECT_EQ(strlen((expected)), (uint32_t) (t).len);  \
+    EXPECT_STREQ((expected), (t).str);                  \
+  } while(0);
+
+TEST(Examples, RoundTripPerson) {
   uint8_t buf[4096];
   ssize_t sz = 0;
 
-  const char *s = "Hello.";
+  const char *name = "Firstname Lastname";
+  const char *email = "username@domain.com";
+  const char *school = "of life";
+
+  struct capn c;
+  capn_init_malloc(&c);
+  capn_ptr cr = capn_root(&c);
+  struct capn_segment *cs = cr.seg;
 
   {
-    // Set initial object in `g`.
+    // Set initial object in `p`.
-    const capn_text capn_val0 = {
+    struct Person p = {
-      .len = (int) strlen(s),
+      .id = 17,
-      .str = s,
+      .name = chars_to_text(name),
-      .seg = NULL
+      .email = chars_to_text(email),
-    };
-    struct Greeting g = {
-      .text = capn_val0,
-      .timesToSay = 17,
     };
+    p.employment_which = Person_employment_school;
+    p.employment.school = chars_to_text(school);
 
-    // Serialize `g` to `buf[0..sz-1]`.
+    p.phones = new_Person_PhoneNumber_list(cs, 2);
-    struct capn c;
+    struct Person_PhoneNumber pn0 = {
-    capn_init_malloc(&c);
+      .number = chars_to_text("123"),
-    capn_ptr cr = capn_root(&c);
+      .type = Person_PhoneNumber_Type_work,
-    struct capn_segment *cs = cr.seg;
+    };
-    Greeting_ptr gp = new_Greeting(cs);
+    set_Person_PhoneNumber(&pn0, p.phones, 0);
-    write_Greeting(&g, gp);
+    struct Person_PhoneNumber pn1 = {
-    int setp_ret = capn_setp(capn_root(&c), 0, gp.p);
+      .number = chars_to_text("234"),
+      .type = Person_PhoneNumber_Type_home,
+    };
+    set_Person_PhoneNumber(&pn1, p.phones, 1);
+
+    Person_ptr pp = new_Person(cs);
+    write_Person(&p, pp);
+    int setp_ret = capn_setp(capn_root(&c), 0, pp.p);
     ASSERT_EQ(0, setp_ret);
     sz = capn_write_mem(&c, buf, sizeof(buf), 0 /* packed */);
     capn_free(&c);
@@ -47,7 +76,7 @@ TEST(Examples, RoundTrip) {
 
   {
     // Write serialized object to file system.
-    FILE *f = fopen("tests/example-test.cpp.Greeting.out", "wb");
+    FILE *f = fopen("tests/example-test.cpp.Person.out", "wb");
     ASSERT_NE(f, (void*)0);
     fwrite(buf, 1 /* size */, sz /* count */, f);
     int close_ret = fclose(f);
@@ -55,18 +84,33 @@ TEST(Examples, RoundTrip) {
   }
 
   {
-    // Deserialize `buf[0..sz-1]` to `rg`.
+    // Deserialize `buf[0..sz-1]` to `rp`.
     struct capn rc;
     int init_mem_ret = capn_init_mem(&rc, buf, sz, 0 /* packed */);
     ASSERT_EQ(0, init_mem_ret);
-    Greeting_ptr rroot;
+    Person_ptr rroot;
-    struct Greeting rg;
+    struct Person rp;
     rroot.p = capn_getp(capn_root(&rc), 0 /* off */, 1 /* resolve */);
-    read_Greeting(&rg, rroot);
+    read_Person(&rp, rroot);
 
-    // Assert deserialized values in `rg`
+    // Assert deserialized values in `rp`
-    EXPECT_EQ(rg.timesToSay, (uint32_t) 17);
+    EXPECT_EQ(rp.id, (uint32_t) 17);
-    EXPECT_EQ(strlen(s), (uint32_t) rg.text.len);
+    EXPECT_CAPN_TEXT_EQ(name, rp.name);
-    EXPECT_EQ(0, strncmp(s, rg.text.str, strlen(s)));
+    EXPECT_CAPN_TEXT_EQ(email, rp.email);
+
+    EXPECT_EQ(rp.employment_which, Person_employment_school);
+    EXPECT_CAPN_TEXT_EQ(school, rp.employment.school);
+
+    struct Person_PhoneNumber rpn0;
+    get_Person_PhoneNumber(&rpn0, rp.phones, 0);
+    EXPECT_CAPN_TEXT_EQ("123", rpn0.number);
+    EXPECT_EQ(rpn0.type, Person_PhoneNumber_Type_work);
+
+    struct Person_PhoneNumber rpn1;
+    get_Person_PhoneNumber(&rpn1, rp.phones, 1);
+    EXPECT_CAPN_TEXT_EQ("234", rpn1.number);
+    EXPECT_EQ(rpn1.type, Person_PhoneNumber_Type_home);
   }
 }
+
+// TODO: Accessor read/write vs read_/write_.

tests/example.capnp

@@ -1,10 +0,0 @@
-@0xd120e9a4c43868ab;
-
-using C = import "/c.capnp";
-
-$C.fieldgetset;
-
-struct Greeting  {
-  text @0 :Text = "Default greeting: hello world!";
-  timesToSay @1 :UInt32;
-}

tests/example.capnp.c

@@ -1,66 +0,0 @@
-#include "example.capnp.h"
-/* AUTO GENERATED - DO NOT EDIT */
-static const capn_text capn_val0 = {0,"",0};
-static const uint8_t capn_buf[32] = {
-	68,101,102,97,117,108,116,32,
-	103,114,101,101,116,105,110,103,
-	58,32,104,101,108,108,111,32,
-	119,111,114,108,100,33,0,0
-};
-static const struct capn_segment capn_seg = {{0},0,0,0,(char*)&capn_buf[0],32,32,0};
-static capn_text capn_val1 = {30,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg};
-
-Greeting_ptr new_Greeting(struct capn_segment *s) {
-	Greeting_ptr p;
-	p.p = capn_new_struct(s, 8, 1);
-	return p;
-}
-Greeting_list new_Greeting_list(struct capn_segment *s, int len) {
-	Greeting_list p;
-	p.p = capn_new_list(s, len, 8, 1);
-	return p;
-}
-void read_Greeting(struct Greeting *s, Greeting_ptr p) {
-	capn_resolve(&p.p);
-	s->text = capn_get_text(p.p, 0, capn_val1);
-	s->timesToSay = capn_read32(p.p, 0);
-}
-void write_Greeting(const struct Greeting *s, Greeting_ptr p) {
-	capn_resolve(&p.p);
-	capn_set_text(p.p, 0, (s->text.str != capn_val1.str) ? s->text : capn_val0);
-	capn_write32(p.p, 0, s->timesToSay);
-}
-void get_Greeting(struct Greeting *s, Greeting_list l, int i) {
-	Greeting_ptr p;
-	p.p = capn_getp(l.p, i, 0);
-	read_Greeting(s, p);
-}
-void set_Greeting(const struct Greeting *s, Greeting_list l, int i) {
-	Greeting_ptr p;
-	p.p = capn_getp(l.p, i, 0);
-	write_Greeting(s, p);
-}
-
-capn_text Greeting_get_text(Greeting_ptr p)
-{
-	capn_text text;
-	text = capn_get_text(p.p, 0, capn_val1);
-	return text;
-}
-
-uint32_t Greeting_get_timesToSay(Greeting_ptr p)
-{
-	uint32_t timesToSay;
-	timesToSay = capn_read32(p.p, 0);
-	return timesToSay;
-}
-
-void Greeting_set_text(Greeting_ptr p, capn_text text)
-{
-	capn_set_text(p.p, 0, (text.str != capn_val1.str) ? text : capn_val0);
-}
-
-void Greeting_set_timesToSay(Greeting_ptr p, uint32_t timesToSay)
-{
-	capn_write32(p.p, 0, timesToSay);
-}

tests/example.capnp.h

@@ -1,56 +0,0 @@
-#ifndef CAPN_D120E9A4C43868AB
-#define CAPN_D120E9A4C43868AB
-/* AUTO GENERATED - DO NOT EDIT */
-#include <capnp_c.h>
-
-#if CAPN_VERSION != 1
-#error "version mismatch between capnp_c.h and generated code"
-#endif
-
-#include "c.capnp.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct Greeting;
-
-typedef struct {capn_ptr p;} Greeting_ptr;
-
-typedef struct {capn_ptr p;} Greeting_list;
-
-struct Greeting {
-	capn_text text;
-	uint32_t timesToSay;
-};
-
-static const size_t Greeting_word_count = 1;
-
-static const size_t Greeting_pointer_count = 1;
-
-static const size_t Greeting_struct_bytes_count = 16;
-
-capn_text Greeting_get_text(Greeting_ptr p);
-
-uint32_t Greeting_get_timesToSay(Greeting_ptr p);
-
-void Greeting_set_text(Greeting_ptr p, capn_text text);
-
-void Greeting_set_timesToSay(Greeting_ptr p, uint32_t timesToSay);
-
-Greeting_ptr new_Greeting(struct capn_segment*);
-
-Greeting_list new_Greeting_list(struct capn_segment*, int len);
-
-void read_Greeting(struct Greeting*, Greeting_ptr);
-
-void write_Greeting(const struct Greeting*, Greeting_ptr);
-
-void get_Greeting(struct Greeting*, Greeting_list, int i);
-
-void set_Greeting(const struct Greeting*, Greeting_list, int i);
-
-#ifdef __cplusplus
-}
-#endif
-#endif