[WIP, DNM] Adding test scripts

cborattr/Kconfig

@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE image
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this image
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this image except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#  http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# Under the License.
+
+config CBORATTR_MAX_SIZE
+    int "Maximum chunk size for image uploads"
+    default 512
+    help
+      The maximum size of a CBOR attribute during decoding

cborattr/include/cborattr/cborattr.h

@@ -26,7 +26,11 @@
 #include <ctype.h>
 #include <stdio.h>
 #include <sys/types.h>
-#include "cbor.h"
+#include "tinycbor/cbor.h"
+
+#ifdef MYNEWT
+#include <os/os_mbuf.h>
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -117,6 +121,43 @@ struct cbor_attr_t {
     bool nodefault;
 };
 
+#ifndef __ZEPHYR__
+/** An array value to be encoded as CBOR. */
+struct cbor_out_arr_val_t {
+    struct cbor_out_val_t *elems;
+    size_t len;
+};
+
+/** A single value to be encoded as CBOR. */
+struct cbor_out_val_t {
+    /** The type of data. */
+    CborAttrType type;
+
+    /** The data value. */
+    union {
+        long long int integer;
+        long long unsigned int uinteger;
+        double real;
+        float fval;
+        const char *string;
+        bool boolean;
+        struct {
+            const uint8_t *data;
+            size_t len;
+        } bytestring;
+        struct cbor_out_arr_val_t array;
+        struct cbor_out_attr_t *obj; /* Terminated with a type=0 entry. */
+    };
+};
+
+/** An object key-value pair to be encoded as CBOR. */
+struct cbor_out_attr_t {
+    const char *attribute;      /** The attribute name (key). */
+    struct cbor_out_val_t val;  /** The attribute value. */
+    bool omit;                  /** Attribute ignored if true. */
+};
+#endif
+
 /*
  * Use the following macros to declare template initializers for
  * CborAttrStructObjectType arrays. Writing the equivalents out by hand is
@@ -144,7 +185,33 @@ int cbor_read_array(struct CborValue *, const struct cbor_array_t *);
 
 int cbor_read_flat_attrs(const uint8_t *data, int len,
                          const struct cbor_attr_t *attrs);
+#ifdef MYNEWT
+int cbor_read_mbuf_attrs(struct os_mbuf *m, uint16_t off, uint16_t len,
+                         const struct cbor_attr_t *attrs);
+
+/**
+ * @brief Encodes a CBOR representation of the specified key-value map.
+ *
+ * @param enc                   The CBOR encoder to write to.
+ * @param attrs                 The key-value map to encode.
+ *
+ * @return                      0 on success; SYS_E[...] error on failure.
+ */
+int cbor_write_object(struct CborEncoder *enc,
+                      const struct cbor_out_attr_t *attrs);
 
+/**
+ * @brief Encodes a CBOR representation of the specified key-value map into an
+ * msys mbuf chain.
+ *
+ * @param attrs                 The key-value map to encode.
+ * @param out_om                On success, points to the populate mbuf chain.
+ *
+ * @return                      0 on success; SYS_E[...] error on failure.
+ */
+int cbor_write_object_msys(const struct cbor_out_attr_t *attrs,
+                           struct os_mbuf **out_om);
+#endif
 #ifdef __cplusplus
 }
 #endif

cborattr/pkg.yml

@@ -24,6 +24,6 @@ pkg.homepage: "http://mynewt.apache.org/"
 pkg.keywords:
 
 pkg.deps:
-    - "encoding/tinycbor"
+    - "@apache-mynewt-core/encoding/tinycbor"
 
 pkg.cflags.FLOAT_USER: -DFLOAT_SUPPORT

cborattr/src/cborattr.c

@@ -19,10 +19,21 @@
 
 //#include <syscfg/syscfg.h>
 #include "cborattr/cborattr.h"
-#include "cbor.h"
-#include "cbor_buf_reader.h"
+#include "tinycbor/cbor.h"
+#include "tinycbor/cbor_buf_reader.h"
+
+#ifdef MYNEWT
+#include "tinycbor/cbor_mbuf_reader.h"
+#include "tinycbor/cbor_mbuf_writer.h"
+#include "os/os_mbuf.h"
+#define CBORATTR_MAX_SIZE MYNEWT_VAL(CBORATTR_MAX_SIZE)
+#else
+#define CBORATTR_MAX_SIZE CONFIG_CBORATTR_MAX_SIZE
+#endif
 
-#define CBORATTR_MAX_SIZE 512
+
+static int cbor_write_val(struct CborEncoder *enc,
+                          const struct cbor_out_val_t *val);
 
 /* this maps a CborType to a matching CborAtter Type. The mapping is not
  * one-to-one because of signedness of integers
@@ -180,6 +191,7 @@ cbor_internal_read_object(CborValue *root_value,
         }
     }
 
+
     if (cbor_value_is_map(root_value)) {
         err |= cbor_value_enter_container(root_value, &cur_value);
     } else {
@@ -386,14 +398,18 @@ cbor_read_flat_attrs(const uint8_t *data, int len,
     CborError err;
 
     cbor_buf_reader_init(&reader, data, len);
+#ifdef __ZEPHYR__
     err = cbor_parser_cust_reader_init(&reader.r, 0, &parser, &value);
+#else
+    err = cbor_parser_init(&reader.r, 0, &parser, &value);
+#endif
     if (err != CborNoError) {
         return -1;
     }
     return cbor_read_object(&value, attrs);
 }
 
-#if 0
+#ifdef MYNEWT
 /*
  * Read in cbor key/values from os_mbuf pointed by m, and fill them
  * into attrs.
@@ -421,4 +437,186 @@ cbor_read_mbuf_attrs(struct os_mbuf *m, uint16_t off, uint16_t len,
     }
     return cbor_read_object(&value, attrs);
 }
+
+static int
+cbor_write_arr_val(struct CborEncoder *enc,
+                   const struct cbor_out_arr_val_t *arr)
+{
+    struct CborEncoder arr_enc;
+    size_t i;
+    int rc;
+
+    rc = cbor_encoder_create_array(enc, &arr_enc, arr->len);
+    if (rc != 0) {
+        return SYS_ENOMEM;
+    }
+
+    for (i = 0; i < arr->len; i++) {
+        rc = cbor_write_val(&arr_enc, &arr->elems[i]);
+        if (rc != 0) {
+            return SYS_ENOMEM;
+        }
+    }
+
+    rc = cbor_encoder_close_container(enc, &arr_enc);
+    if (rc != 0) {
+        return SYS_ENOMEM;
+    }
+
+    return 0;
+}
+
+static int
+cbor_write_val(struct CborEncoder *enc, const struct cbor_out_val_t *val)
+{
+    int len;
+    int rc;
+
+    switch (val->type) {
+    case CborAttrNullType:
+        rc = cbor_encode_null(enc);
+        break;
+
+    case CborAttrBooleanType:
+        rc = cbor_encode_boolean(enc, val->boolean);
+        break;
+
+    case CborAttrIntegerType:
+        rc = cbor_encode_int(enc, val->integer);
+        break;
+
+    case CborAttrUnsignedIntegerType:
+        rc = cbor_encode_uint(enc, val->uinteger);
+        break;
+
+#if FLOAT_SUPPORT
+    case CborAttrFloatType:
+        rc = cbor_encode_float(enc, val->fval);
+        break;
+
+    case CborAttrDoubleType:
+        rc = cbor_encode_double(enc, val->real);
+        break;
+#endif
+
+    case CborAttrByteStringType:
+        if (val->bytestring.data == NULL &&
+            val->bytestring.len != 0) {
+
+            return SYS_EINVAL;
+        }
+
+        rc = cbor_encode_byte_string(enc, val->bytestring.data,
+                                     val->bytestring.len);
+        break;
+
+    case CborAttrTextStringType:
+        if (val->string == NULL) {
+            len = 0;
+        } else {
+            len = strlen(val->string);
+        }
+        rc = cbor_encode_text_string(enc, val->string, len);
+        break;
+
+    case CborAttrObjectType:
+        rc = cbor_write_object(enc, val->obj);
+        break;
+
+    case CborAttrArrayType:
+        rc = cbor_write_arr_val(enc, &val->array);
+        break;
+
+    default:
+        return SYS_ENOTSUP;
+    }
+
+    if (rc != 0) {
+        return SYS_ENOMEM;
+    }
+
+    return 0;
+}
+
+static int
+cbor_write_attr(struct CborEncoder *enc, const struct cbor_out_attr_t *attr)
+{
+    int len;
+    int rc;
+
+    if (attr->omit) {
+        return 0;
+    }
+
+    if (!attr->attribute) {
+        rc = SYS_EINVAL;
+        return rc;
+    }
+
+    len = strlen(attr->attribute);
+    rc = cbor_encode_text_string(enc, attr->attribute, len);
+    if (rc != 0) {
+        return rc;
+    } 
+
+    rc = cbor_write_val(enc, &attr->val);
+    if (rc != 0) {
+        return rc;
+    } 
+
+    return 0;
+}
+
+int
+cbor_write_object(struct CborEncoder *enc, const struct cbor_out_attr_t *attrs)
+{
+    const struct cbor_out_attr_t *attr;
+    struct CborEncoder map;
+    int rc;
+
+    rc = cbor_encoder_create_map(enc, &map, CborIndefiniteLength);
+    if (rc != 0) {
+        return SYS_ENOMEM;
+    }
+
+    for (attr = attrs; attr->val.type != 0; attr++) {
+        rc = cbor_write_attr(&map, attr);
+        if (rc != 0) {
+            return rc;
+        }
+    }
+
+    rc = cbor_encoder_close_container(enc, &map);
+    if (rc != 0) {
+        return SYS_ENOMEM;
+    }
+
+    return 0;
+}
+
+int
+cbor_write_object_msys(const struct cbor_out_attr_t *attrs,
+                       struct os_mbuf **out_om)
+{
+    struct cbor_mbuf_writer writer;
+    struct CborEncoder encoder;
+    int rc;
+
+    *out_om = os_msys_get_pkthdr(0, 0);
+    if (*out_om == NULL) {
+        return SYS_ENOMEM;
+    }
+
+    cbor_mbuf_writer_init(&writer, *out_om);
+    cbor_encoder_init(&encoder, &writer.enc, 0);
+
+    rc = cbor_write_object(&encoder, attrs);
+    if (rc != 0) {
+        os_mbuf_free_chain(*out_om);
+        *out_om = NULL;
+        return rc;
+    }
+
+    return 0;
+}
 #endif

cborattr/test/pkg.yml

@@ -23,8 +23,10 @@ pkg.homepage: "http://mynewt.apache.org/"
 pkg.keywords:
 
 pkg.deps:
-    - '@mynewt-mcumgr/ext/tinycbor'
-    - '@mynewt-mcumgr/cborattr'
+    - '@apache-mynewt-core/encoding/tinycbor'
+    - '@apache-mynewt-mcumgr/cborattr'
 
 pkg.deps.SELFTEST:
-    - sys/console/stub
+    - '@apache-mynewt-core/sys/console/stub'
+    - '@apache-mynewt-core/sys/log/full'
+    - '@apache-mynewt-core/test/testutil'

cborattr/test/src/test_cborattr.h

@@ -35,6 +35,8 @@ extern "C" {
  */
 const uint8_t *test_str1(int *len);
 
+void cborattr_test_util_encode(const struct cbor_out_attr_t *attrs,
+                               const uint8_t *expected, int len);
 /*
  * Testcases
  */