Separation Generator to a dedicated repo

Change-Id: Id94831651c3266861435272a6e36c7884bef2c45
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

3 files changed, 0 insertions, 175 deletions

diff --git a/CAN-binder/libs/nanopb/tests/intsizes/SConscript b/CAN-binder/libs/nanopb/tests/intsizes/SConscript
deleted file mode 100644
index a90680bc..00000000
--- a/CAN-binder/libs/nanopb/tests/intsizes/SConscript
+++ /dev/null
@@ -1,12 +0,0 @@
-# Test that the int_size option in .proto works.
-
-Import('env')
-
-env.NanopbProto('intsizes')
-
-p = env.Program(["intsizes_unittests.c",
-                 "intsizes.pb.c",
-                 "$COMMON/pb_encode.o",
-                 "$COMMON/pb_decode.o",
-                 "$COMMON/pb_common.o"])
-env.RunTest(p)
diff --git a/CAN-binder/libs/nanopb/tests/intsizes/intsizes.proto b/CAN-binder/libs/nanopb/tests/intsizes/intsizes.proto
deleted file mode 100644
index 91444d41..00000000
--- a/CAN-binder/libs/nanopb/tests/intsizes/intsizes.proto
+++ /dev/null
@@ -1,41 +0,0 @@
-/* Test the integer size overriding in nanopb options.
- * This allows to use 8- and 16-bit integer variables, which are not supported
- * directly by Google Protobuf.
- *
- * The int_size setting will override the number of bits, but keep the type
- * otherwise. E.g. uint32 + IS_8 => uint8_t
- */
-
-syntax = "proto2";
-
-import 'nanopb.proto';
-
-message IntSizes {
-    required int32  req_int8 =   1  [(nanopb).int_size = IS_8];
-    required uint32 req_uint8 =  2  [(nanopb).int_size = IS_8];
-    required sint32 req_sint8 =  3  [(nanopb).int_size = IS_8];
-    required int32  req_int16 =  4  [(nanopb).int_size = IS_16];
-    required uint32 req_uint16 = 5  [(nanopb).int_size = IS_16];
-    required sint32 req_sint16 = 6  [(nanopb).int_size = IS_16];
-    required int32  req_int32 =  7  [(nanopb).int_size = IS_32];
-    required uint32 req_uint32 = 8  [(nanopb).int_size = IS_32];
-    required sint32 req_sint32 = 9  [(nanopb).int_size = IS_32];
-    required int32  req_int64 =  10 [(nanopb).int_size = IS_64];
-    required uint32 req_uint64 = 11 [(nanopb).int_size = IS_64];
-    required sint32 req_sint64 = 12 [(nanopb).int_size = IS_64];
-}
-
-message DefaultSizes {
-    required int32  req_int8 =   1 ;
-    required uint32 req_uint8 =  2 ;
-    required sint32 req_sint8 =  3 ;
-    required int32  req_int16 =  4 ;
-    required uint32 req_uint16 = 5 ;
-    required sint32 req_sint16 = 6 ;
-    required int32  req_int32 =  7 ;
-    required uint32 req_uint32 = 8 ;
-    required sint32 req_sint32 = 9 ;
-    required int64  req_int64 =  10;
-    required uint64 req_uint64 = 11;
-    required sint64 req_sint64 = 12;
-}
diff --git a/CAN-binder/libs/nanopb/tests/intsizes/intsizes_unittests.c b/CAN-binder/libs/nanopb/tests/intsizes/intsizes_unittests.c
deleted file mode 100644
index 79ef0369..00000000
--- a/CAN-binder/libs/nanopb/tests/intsizes/intsizes_unittests.c
+++ /dev/null
@@ -1,122 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <pb_decode.h>
-#include <pb_encode.h>
-#include "unittests.h"
-#include "intsizes.pb.h"
-
-#define S(x) pb_istream_from_buffer((uint8_t*)x, sizeof(x) - 1)
-
-/* This is a macro instead of function in order to get the actual values
- * into the TEST() lines in output */
-#define TEST_ROUNDTRIP(int8, uint8, sint8, \
-                       int16, uint16, sint16, \
-                       int32, uint32, sint32, \
-                       int64, uint64, sint64, expected_result) \
-{                                                                           \
-    uint8_t buffer1[128], buffer2[128];                                     \
-    size_t msgsize;                                                         \
-    DefaultSizes msg1 = DefaultSizes_init_zero;                             \
-    IntSizes msg2 = IntSizes_init_zero;                                     \
-                                                                            \
-    msg1.req_int8   = int8;                                                 \
-    msg1.req_uint8  = uint8;                                                \
-    msg1.req_sint8  = sint8;                                                \
-    msg1.req_int16  = int16;                                                \
-    msg1.req_uint16 = uint16;                                               \
-    msg1.req_sint16 = sint16;                                               \
-    msg1.req_int32  = int32;                                                \
-    msg1.req_uint32 = uint32;                                               \
-    msg1.req_sint32 = sint32;                                               \
-    msg1.req_int64  = int64;                                                \
-    msg1.req_uint64 = uint64;                                               \
-    msg1.req_sint64 = sint64;                                               \
-                                                                            \
-    {                                                                       \
-        pb_ostream_t s = pb_ostream_from_buffer(buffer1, sizeof(buffer1));  \
-        TEST(pb_encode(&s, DefaultSizes_fields, &msg1));                    \
-        msgsize = s.bytes_written;                                          \
-    }                                                                       \
-                                                                            \
-    {                                                                       \
-        pb_istream_t s = pb_istream_from_buffer(buffer1, msgsize);          \
-        TEST(pb_decode(&s, IntSizes_fields, &msg2) == expected_result);     \
-        if (expected_result)                                                \
-        {                                                                   \
-            TEST( (int64_t)msg2.req_int8   == int8);                        \
-            TEST((uint64_t)msg2.req_uint8  == uint8);                       \
-            TEST( (int64_t)msg2.req_sint8  == sint8);                       \
-            TEST( (int64_t)msg2.req_int16  == int16);                       \
-            TEST((uint64_t)msg2.req_uint16 == uint16);                      \
-            TEST( (int64_t)msg2.req_sint16 == sint16);                      \
-            TEST( (int64_t)msg2.req_int32  == int32);                       \
-            TEST((uint64_t)msg2.req_uint32 == uint32);                      \
-            TEST( (int64_t)msg2.req_sint32 == sint32);                      \
-            TEST( (int64_t)msg2.req_int64  == int64);                       \
-            TEST((uint64_t)msg2.req_uint64 == uint64);                      \
-            TEST( (int64_t)msg2.req_sint64 == sint64);                      \
-        }                                                                   \
-    }                                                                       \
-                                                                            \
-    if (expected_result)                                                    \
-    {                                                                       \
-        pb_ostream_t s = pb_ostream_from_buffer(buffer2, sizeof(buffer2));  \
-        TEST(pb_encode(&s, IntSizes_fields, &msg2));                        \
-        TEST(s.bytes_written == msgsize);                                   \
-        TEST(memcmp(buffer1, buffer2, msgsize) == 0);                       \
-    }                                                                       \
-}
-
-int main()
-{
-    int status = 0;
-
-    {
-        IntSizes msg = IntSizes_init_zero;
-
-        COMMENT("Test field sizes");
-        TEST(sizeof(msg.req_int8) == 1);
-        TEST(sizeof(msg.req_uint8) == 1);
-        TEST(sizeof(msg.req_sint8) == 1);
-        TEST(sizeof(msg.req_int16) == 2);
-        TEST(sizeof(msg.req_uint16) == 2);
-        TEST(sizeof(msg.req_sint16) == 2);
-        TEST(sizeof(msg.req_int32) == 4);
-        TEST(sizeof(msg.req_uint32) == 4);
-        TEST(sizeof(msg.req_sint32) == 4);
-        TEST(sizeof(msg.req_int64) == 8);
-        TEST(sizeof(msg.req_uint64) == 8);
-        TEST(sizeof(msg.req_sint64) == 8);
-    }
-
-    COMMENT("Test roundtrip at maximum value");
-    TEST_ROUNDTRIP(127,     255,    127,
-                   32767, 65535,  32767,
-                   INT32_MAX, UINT32_MAX, INT32_MAX,
-                   INT64_MAX, UINT64_MAX, INT64_MAX, true);
-
-    COMMENT("Test roundtrip at minimum value");
-    TEST_ROUNDTRIP(-128,      0,   -128,
-                   -32768,    0, -32768,
-                   INT32_MIN, 0, INT32_MIN,
-                   INT64_MIN, 0, INT64_MIN, true);
-
-    COMMENT("Test overflow detection");
-    TEST_ROUNDTRIP(-129,      0,   -128,
-                   -32768,    0, -32768,
-                   INT32_MIN, 0, INT32_MIN,
-                   INT64_MIN, 0, INT64_MIN, false);
-    TEST_ROUNDTRIP(127,     256,    127,
-                   32767, 65535,  32767,
-                   INT32_MAX, UINT32_MAX, INT32_MAX,
-                   INT64_MAX, UINT64_MAX, INT64_MAX, false);
-    TEST_ROUNDTRIP(-128,      0,   -128,
-                   -32768,    0, -32769,
-                   INT32_MIN, 0, INT32_MIN,
-                   INT64_MIN, 0, INT64_MIN, false);
-
-    if (status != 0)
-        fprintf(stdout, "\n\nSome tests FAILED!\n");
-
-    return status;
-}
\ No newline at end of file