summaryrefslogtreecommitdiffstats
path: root/recipes-platform/images/agl-image-ivi-crosssdk.bb
diff options
context:
space:
mode:
authorJan-Simon Möller <jsmoeller@linuxfoundation.org>2018-05-15 14:47:00 +0200
committerJan-Simon Möller <jsmoeller@linuxfoundation.org>2018-06-05 15:11:36 +0200
commitb6852864508358930586e083e72cd2912af68674 (patch)
tree4029e33f00bbd0247524d03f7c1689672d85ef9b /recipes-platform/images/agl-image-ivi-crosssdk.bb
parentfab778caff2041794814df54b51893965381aa66 (diff)
3rd part of the layer/profile rework [2/2]
This is the last part of the layer rework series. Notable changes are: - move demo specific recipes to the demo (dlt, web-runtime mocca-usb) - wayland-ivi-extension moved to the meta-agl-demo layer for now. - web-runtime moved here (from appfw layer to allow console-only builds with appfw) - adapted packagegroups and agl-features v2: squashed with commit on sandbox to form single commit (tnx, Scott) v3: inclusion of old packagegroup-agl-image-ivi (TODO: refactor and include in profile packagegroups. Tnx, Stephane) v4: base packagegroup-agl-demo-platform on packagegroup-agl-profile-graphical-qt5 v5: fix MOST_DRIVERS_append (disable due to FTBS) v6: re-add RDEPENDS for virtual/pulseaudio-config Bug-AGL: SPEC-145 Bug-AGL: SPEC-1422 Change-Id: I20bd5b9a957ea54a7ecd08bd4f8b99a32266c9c8 Signed-off-by: Jan-Simon Möller <jsmoeller@linuxfoundation.org>
Diffstat (limited to 'recipes-platform/images/agl-image-ivi-crosssdk.bb')
-rw-r--r--recipes-platform/images/agl-image-ivi-crosssdk.bb19
1 files changed, 19 insertions, 0 deletions
diff --git a/recipes-platform/images/agl-image-ivi-crosssdk.bb b/recipes-platform/images/agl-image-ivi-crosssdk.bb
new file mode 100644
index 000000000..0303d051d
--- /dev/null
+++ b/recipes-platform/images/agl-image-ivi-crosssdk.bb
@@ -0,0 +1,19 @@
+SUMMARY = "Cross SDK of AGL Distribution for IVI profile"
+
+DESCRIPTION = "Basic image for baseline of AGL Distribution for IVI profile. \
+It includes the full meta-toolchain, plus developement headers and libraries \
+to form a standalone cross SDK."
+
+require agl-image-ivi.bb
+
+LICENSE = "MIT"
+
+IMAGE_FEATURES += "dev-pkgs"
+IMAGE_INSTALL += "kernel-dev"
+
+inherit populate_sdk
+
+# Task do_populate_sdk and do_rootfs can't be exec simultaneously.
+# Both exec "createrepo" on the same directory, and so one of them
+# can failed (randomly).
+addtask do_populate_sdk after do_rootfs
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 
#define NANOPB_INTERNALS

#include <stdio.h>
#include <string.h>
#include "pb_encode.h"
#include "unittests.h"
#include "unittestproto.pb.h"

bool streamcallback(pb_ostream_t *stream, const uint8_t *buf, size_t count)
{
    /* Allow only 'x' to be written */
    while (count--)
    {
        if (*buf++ != 'x')
            return false;
    }
    return true;
}

bool fieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
{
    int value = 0x55;
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    return pb_encode_varint(stream, value);
}

bool crazyfieldcallback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg)
{
    /* This callback writes different amount of data the second time. */
    uint32_t *state = (uint32_t*)arg;
    *state <<= 8;
    if (!pb_encode_tag_for_field(stream, field))
        return false;
    return pb_encode_varint(stream, *state);
}

/* Check that expression x writes data y.
 * Y is a string, which may contain null bytes. Null terminator is ignored.
 */
#define WRITES(x, y) \
memset(buffer, 0xAA, sizeof(buffer)), \
s = pb_ostream_from_buffer(buffer, sizeof(buffer)), \
(x) && \
memcmp(buffer, y, sizeof(y) - 1) == 0 && \
buffer[sizeof(y) - 1] == 0xAA

int main()
{
    int status = 0;
    
    {
        uint8_t buffer1[] = "foobartest1234";
        uint8_t buffer2[sizeof(buffer1)];
        pb_ostream_t stream = pb_ostream_from_buffer(buffer2, sizeof(buffer1));
        
        COMMENT("Test pb_write and pb_ostream_t");
        TEST(pb_write(&stream, buffer1, sizeof(buffer1)));
        TEST(memcmp(buffer1, buffer2, sizeof(buffer1)) == 0);
        TEST(!pb_write(&stream, buffer1, 1));
        TEST(stream.bytes_written == sizeof(buffer1));
    }
    
    {
        uint8_t buffer1[] = "xxxxxxx";
        pb_ostream_t stream = {&streamcallback, 0, SIZE_MAX, 0};
        
        COMMENT("Test pb_write with custom callback");
        TEST(pb_write(&stream, buffer1, 5));
        buffer1[0] = 'a';
        TEST(!pb_write(&stream, buffer1, 5));
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        
        COMMENT("Test pb_encode_varint")
        TEST(WRITES(pb_encode_varint(&s, 0), "\0"));
        TEST(WRITES(pb_encode_varint(&s, 1), "\1"));
        TEST(WRITES(pb_encode_varint(&s, 0x7F), "\x7F"));
        TEST(WRITES(pb_encode_varint(&s, 0x80), "\x80\x01"));
        TEST(WRITES(pb_encode_varint(&s, UINT32_MAX), "\xFF\xFF\xFF\xFF\x0F"));
        TEST(WRITES(pb_encode_varint(&s, UINT64_MAX), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        
        COMMENT("Test pb_encode_tag")
        TEST(WRITES(pb_encode_tag(&s, PB_WT_STRING, 5), "\x2A"));
        TEST(WRITES(pb_encode_tag(&s, PB_WT_VARINT, 99), "\x98\x06"));
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        pb_field_t field = {10, PB_LTYPE_SVARINT};
        
        COMMENT("Test pb_encode_tag_for_field")
        TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x50"));
        
        field.type = PB_LTYPE_FIXED64;
        TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x51"));
        
        field.type = PB_LTYPE_STRING;
        TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x52"));
        
        field.type = PB_LTYPE_FIXED32;
        TEST(WRITES(pb_encode_tag_for_field(&s, &field), "\x55"));
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        
        COMMENT("Test pb_encode_string")
        TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"abcd", 4), "\x04""abcd"));
        TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"abcd\x00", 5), "\x05""abcd\x00"));
        TEST(WRITES(pb_encode_string(&s, (const uint8_t*)"", 0), "\x00"));
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        uint8_t value = 1;
        int32_t max = INT32_MAX;
        int32_t min = INT32_MIN;
        int64_t lmax = INT64_MAX;
        int64_t lmin = INT64_MIN;
        pb_field_t field = {1, PB_LTYPE_VARINT, 0, 0, sizeof(value)};
        
        COMMENT("Test pb_enc_varint and pb_enc_svarint")
        TEST(WRITES(pb_enc_varint(&s, &field, &value), "\x01"));
        
        field.data_size = sizeof(max);
        TEST(WRITES(pb_enc_svarint(&s, &field, &max), "\xfe\xff\xff\xff\x0f"));
        TEST(WRITES(pb_enc_svarint(&s, &field, &min), "\xff\xff\xff\xff\x0f"));
        
        field.data_size = sizeof(lmax);
        TEST(WRITES(pb_enc_svarint(&s, &field, &lmax), "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
        TEST(WRITES(pb_enc_svarint(&s, &field, &lmin), "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01"));
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        float fvalue;
        double dvalue;
        
        COMMENT("Test pb_enc_fixed32 using float")
        fvalue = 0.0f;
        TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x00\x00\x00\x00"))
        fvalue = 99.0f;
        TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x00\x00\xc6\x42"))
        fvalue = -12345678.0f;
        TEST(WRITES(pb_enc_fixed32(&s, NULL, &fvalue), "\x4e\x61\x3c\xcb"))
    
        COMMENT("Test pb_enc_fixed64 using double")
        dvalue = 0.0;
        TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\x00\x00\x00\x00\x00"))
        dvalue = 99.0;
        TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\x00\x00\xc0\x58\x40"))
        dvalue = -12345678.0;
        TEST(WRITES(pb_enc_fixed64(&s, NULL, &dvalue), "\x00\x00\x00\xc0\x29\x8c\x67\xc1"))
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        struct { size_t size; uint8_t bytes[5]; } value = {5, {'x', 'y', 'z', 'z', 'y'}};
    
        COMMENT("Test pb_enc_bytes")
        TEST(WRITES(pb_enc_bytes(&s, NULL, &value), "\x05xyzzy"))
        value.size = 0;
        TEST(WRITES(pb_enc_bytes(&s, NULL, &value), "\x00"))
    }
    
    {
        uint8_t buffer[30];
        pb_ostream_t s;
        char value[30] = "xyzzy";
        
        COMMENT("Test pb_enc_string")
        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x05xyzzy"))
        value[0] = '\0';
        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x00"))
        memset(value, 'x', 30);
        TEST(WRITES(pb_enc_string(&s, &StringMessage_fields[0], &value), "\x0Axxxxxxxxxx"))
    }
    
    {
        uint8_t buffer[10];
        pb_ostream_t s;
        IntegerArray msg = {5, {1, 2, 3, 4, 5}};
        
        COMMENT("Test pb_encode with int32 array")
        
        TEST(WRITES(pb_encode(&s, IntegerArray_fields, &msg), "\x0A\x05\x01\x02\x03\x04\x05"))
        
        msg.data_count = 0;
        TEST(WRITES(pb_encode(&s, IntegerArray_fields, &msg), ""))
        
        msg.data_count = 10;
        TEST(!pb_encode(&s, IntegerArray_fields, &msg))
    }
    
    {
        uint8_t buffer[10];
        pb_ostream_t s;
        FloatArray msg = {1, {99.0f}};
        
        COMMENT("Test pb_encode with float array")
        
        TEST(WRITES(pb_encode(&s, FloatArray_fields, &msg),
                    "\x0A\x04\x00\x00\xc6\x42"))
        
        msg.data_count = 0;
        TEST(WRITES(pb_encode(&s, FloatArray_fields, &msg), ""))
        
        msg.data_count = 3;
        TEST(!pb_encode(&s, FloatArray_fields, &msg))
    }
    
    {
        uint8_t buffer[10];
        pb_ostream_t s;
        CallbackArray msg;
        
        msg.data.funcs.encode = &fieldcallback;
        
        COMMENT("Test pb_encode with callback field.")
        TEST(WRITES(pb_encode(&s, CallbackArray_fields, &msg), "\x08\x55"))
    }
    
    {
        uint8_t buffer[10];
        pb_ostream_t s;
        IntegerContainer msg = {{5, {1,2,3,4,5}}};
        
        COMMENT("Test pb_encode with packed array in a submessage.")
        TEST(WRITES(pb_encode(&s, IntegerContainer_fields, &msg),
                    "\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
    }
    
    {
        uint8_t buffer[20];
        pb_ostream_t s;
        IntegerContainer msg = {{5, {1,2,3,4,5}}};
        
        COMMENT("Test pb_encode_delimited.")
        TEST(WRITES(pb_encode_delimited(&s, IntegerContainer_fields, &msg),
                    "\x09\x0A\x07\x0A\x05\x01\x02\x03\x04\x05"))
    }
    
    {
        uint8_t buffer[10];
        pb_ostream_t s;
        CallbackContainer msg;
        CallbackContainerContainer msg2;
        uint32_t state = 1;
        
        msg.submsg.data.funcs.encode = &fieldcallback;
        msg2.submsg.submsg.data.funcs.encode = &fieldcallback;
        
        COMMENT("Test pb_encode with callback field in a submessage.")
        TEST(WRITES(pb_encode(&s, CallbackContainer_fields, &msg), "\x0A\x02\x08\x55"))
        TEST(WRITES(pb_encode(&s, CallbackContainerContainer_fields, &msg2),
                    "\x0A\x04\x0A\x02\x08\x55"))
        
        /* Misbehaving callback: varying output between calls */
        msg.submsg.data.funcs.encode = &crazyfieldcallback;
        msg.submsg.data.arg = &state;
        msg2.submsg.submsg.data.funcs.encode = &crazyfieldcallback;
        msg2.submsg.submsg.data.arg = &state;
        
        TEST(!pb_encode(&s, CallbackContainer_fields, &msg))
        state = 1;
        TEST(!pb_encode(&s, CallbackContainerContainer_fields, &msg2))
    }
    
    if (status != 0)
        fprintf(stdout, "\n\nSome tests FAILED!\n");
    
    return status;
}