diff --git a/tests/any_type/SConscript b/tests/any_type/SConscript
new file mode 100644
index 0000000..7e27703
--- /dev/null
+++ b/tests/any_type/SConscript
@@ -0,0 +1,23 @@
+# Test usage of Any type
+
+Import("env")
+
+incpath = env.Clone()
+incpath.Append(PROTOCPATH = '#any_type')
+incpath.Append(CPPPATH = '$BUILD/any_type')
+
+incpath.NanopbProto("anytest")
+incpath.NanopbProto(["google/protobuf/any", "google/protobuf/any.options"])
+incpath.NanopbProto("google/protobuf/duration")
+
+enc = incpath.Program(["encode_any.c", "anytest.pb.c", "google/protobuf/any.pb.c",
+                       "google/protobuf/duration.pb.c",
+                       "$COMMON/pb_encode.o", "$COMMON/pb_common.o"])
+
+dec = incpath.Program(["decode_any.c", "anytest.pb.c", "google/protobuf/any.pb.c",
+                       "google/protobuf/duration.pb.c",
+                       "$COMMON/pb_decode.o", "$COMMON/pb_common.o"])
+
+env.RunTest(enc)
+env.RunTest([dec, "encode_any.output"])
+
diff --git a/tests/any_type/anytest.proto b/tests/any_type/anytest.proto
new file mode 100644
index 0000000..0b86957
--- /dev/null
+++ b/tests/any_type/anytest.proto
@@ -0,0 +1,27 @@
+// This file is an example and test case on handling the Any type in nanopb.
+// The Any type is defined in Google-provided any.proto file:
+// message Any {
+//      string type_url = 1;
+//      bytes value = 2;
+// }
+//
+// The type_url field identifies the type of message, and the message data
+// is inside the bytes field.
+//
+// The encoding follows the basic format of protobuf and doesn't require
+// special support to handle. In this example, we just set maximum size for
+// the type_url and value fields, and then call pb_decode() again on the value.
+//
+// This does result in unnecessarily copying the data around, so for larger
+// values it is preferrable to use callbacks on the fields instead.
+
+syntax = "proto3";
+import "google/protobuf/any.proto";
+
+message BaseMessage {
+    int32 start = 1;
+    google.protobuf.Any details = 2;
+    int32 end = 3;
+}
+
+
diff --git a/tests/any_type/decode_any.c b/tests/any_type/decode_any.c
new file mode 100644
index 0000000..6aa4b22
--- /dev/null
+++ b/tests/any_type/decode_any.c
@@ -0,0 +1,49 @@
+#include <assert.h>
+#include <pb_decode.h>
+#include <string.h>
+#include <stdio.h>
+#include "test_helpers.h"
+#include "anytest.pb.h"
+#include "google/protobuf/duration.pb.h"
+
+int main()
+{
+    BaseMessage msg = BaseMessage_init_zero;
+    uint8_t buffer[256];
+    pb_istream_t stream;
+    size_t count;
+    bool status;
+    
+    /* Read the data into buffer */
+    SET_BINARY_MODE(stdin);
+    count = fread(buffer, 1, sizeof(buffer), stdin);
+    stream = pb_istream_from_buffer(buffer, count);
+    
+    /* Decode the base message */
+    if (!pb_decode(&stream, BaseMessage_fields, &msg))
+    {
+        printf("Parsing failed: %s\n", PB_GET_ERROR(&stream));
+        return 1;
+    }
+
+    assert(msg.start == 1234);
+    assert(msg.end == 5678);
+
+    /* Decode the Any message if we know the type */
+    if (strcmp(msg.details.type_url, "type.googleapis.com/google.protobuf.Duration") == 0)
+    {
+        google_protobuf_Duration duration = google_protobuf_Duration_init_zero;
+        stream = pb_istream_from_buffer(msg.details.value.bytes, msg.details.value.size);
+        status = pb_decode(&stream, google_protobuf_Duration_fields, &duration);
+        assert(status);
+        assert(duration.seconds == 99999);
+        assert(duration.nanos = 100);
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Unknown Any type\n");
+        return 2;
+    }
+}
+
diff --git a/tests/any_type/encode_any.c b/tests/any_type/encode_any.c
new file mode 100644
index 0000000..dbd4e3d
--- /dev/null
+++ b/tests/any_type/encode_any.c
@@ -0,0 +1,46 @@
+#include <assert.h>
+#include <pb_encode.h>
+#include <string.h>
+#include <stdio.h>
+#include "test_helpers.h"
+#include "anytest.pb.h"
+#include "google/protobuf/duration.pb.h"
+
+int main()
+{
+    BaseMessage msg = BaseMessage_init_zero;
+    google_protobuf_Duration duration = google_protobuf_Duration_init_zero;
+    uint8_t buffer[256];
+    pb_ostream_t stream;
+    bool status;
+    
+    msg.start = 1234;
+    msg.end = 5678;
+
+    /* Fill in the Any message header */
+    msg.has_details = true;
+    strncpy(msg.details.type_url, "type.googleapis.com/google.protobuf.Duration", sizeof(msg.details.type_url));
+    
+    /* Encode a Duration message inside the Any message. */
+    duration.seconds = 99999;
+    duration.nanos = 100;
+    stream = pb_ostream_from_buffer(msg.details.value.bytes, sizeof(msg.details.value.bytes));
+    status = pb_encode(&stream, google_protobuf_Duration_fields, &duration);
+    assert(status);
+    msg.details.value.size = stream.bytes_written;
+    
+    /* Then encode the outer message */
+    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+    if (pb_encode(&stream, BaseMessage_fields, &msg))
+    {    
+        /* Write the result data to stdout */
+        SET_BINARY_MODE(stdout);
+        fwrite(buffer, 1, stream.bytes_written, stdout);
+        return 0;
+    }
+    else
+    {
+        fprintf(stderr, "Encoding failed: %s\n", PB_GET_ERROR(&stream));
+        return 1;
+    }
+}
diff --git a/tests/any_type/google/protobuf/any.options b/tests/any_type/google/protobuf/any.options
new file mode 100644
index 0000000..c88410e
--- /dev/null
+++ b/tests/any_type/google/protobuf/any.options
@@ -0,0 +1,2 @@
+google.protobuf.Any.type_url max_size:64
+google.protobuf.Any.value max_size:64
diff --git a/tests/any_type/google/protobuf/any.proto b/tests/any_type/google/protobuf/any.proto
new file mode 100644
index 0000000..4932942
--- /dev/null
+++ b/tests/any_type/google/protobuf/any.proto
@@ -0,0 +1,154 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/any";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+message Any {
+  // A URL/resource name that uniquely identifies the type of the serialized
+  // protocol buffer message. The last segment of the URL's path must represent
+  // the fully qualified name of the type (as in
+  // `path/google.protobuf.Duration`). The name should be in a canonical form
+  // (e.g., leading "." is not accepted).
+  //
+  // In practice, teams usually precompile into the binary all types that they
+  // expect it to use in the context of Any. However, for URLs which use the
+  // scheme `http`, `https`, or no scheme, one can optionally set up a type
+  // server that maps type URLs to message definitions as follows:
+  //
+  // * If no scheme is provided, `https` is assumed.
+  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+  //   value in binary format, or produce an error.
+  // * Applications are allowed to cache lookup results based on the
+  //   URL, or have them precompiled into a binary to avoid any
+  //   lookup. Therefore, binary compatibility needs to be preserved
+  //   on changes to types. (Use versioned type names to manage
+  //   breaking changes.)
+  //
+  // Note: this functionality is not currently available in the official
+  // protobuf release, and it is not used for type URLs beginning with
+  // type.googleapis.com.
+  //
+  // Schemes other than `http`, `https` (or the empty scheme) might be
+  // used with implementation specific semantics.
+  //
+  string type_url = 1;
+
+  // Must be a valid serialized protocol buffer of the above specified type.
+  bytes value = 2;
+}
diff --git a/tests/any_type/google/protobuf/duration.proto b/tests/any_type/google/protobuf/duration.proto
new file mode 100644
index 0000000..975fce4
--- /dev/null
+++ b/tests/any_type/google/protobuf/duration.proto
@@ -0,0 +1,117 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/duration";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DurationProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (durations.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+message Duration {
+
+  // Signed seconds of the span of time. Must be from -315,576,000,000
+  // to +315,576,000,000 inclusive. Note: these bounds are computed from:
+  // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+  int64 seconds = 1;
+
+  // Signed fractions of a second at nanosecond resolution of the span
+  // of time. Durations less than one second are represented with a 0
+  // `seconds` field and a positive or negative `nanos` field. For durations
+  // of one second or more, a non-zero value for the `nanos` field must be
+  // of the same sign as the `seconds` field. Must be from -999,999,999
+  // to +999,999,999 inclusive.
+  int32 nanos = 2;
+}