archives/pebble
2
0
Fork 0
mirror of https://github.com/google/pebble.git synced 2025-08-22 23:17:22 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Import of the watch repository from Pebble

Browse source
This commit is contained in:
Matthieu Jeanson 2024-12-12 16:43:03 -08:00 • committed by Katharine Berry
commit 3b92768480
10334 changed files with 2564465 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

12
third_party/nanopb/tests/intsizes/SConscript vendored Normal file
View file

@ -0,0 +1,12 @@
# 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)

41
third_party/nanopb/tests/intsizes/intsizes.proto vendored Normal file
View file

@ -0,0 +1,41 @@
/* 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;
}

145
third_party/nanopb/tests/intsizes/intsizes_unittests.c vendored Normal file
View file

@ -0,0 +1,145 @@
#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);
{
uint8_t buffer[128];
IntSizes msg = IntSizes_init_zero;
pb_ostream_t s = pb_ostream_from_buffer(buffer, sizeof(buffer));
COMMENT("Test message maximum size");
msg.req_int8 = -128;
msg.req_uint8 = 255;
msg.req_sint8 = -128;
msg.req_int16 = -32768;
msg.req_uint16 = 65535;
msg.req_sint16 = -32768;
msg.req_int32 = INT32_MIN;
msg.req_uint32 = UINT32_MAX;
msg.req_sint32 = INT32_MIN;
msg.req_int64 = INT64_MIN;
msg.req_uint64 = UINT64_MAX;
msg.req_sint64 = INT64_MIN;
TEST(pb_encode(&s, IntSizes_fields, &msg));
TEST(s.bytes_written == IntSizes_size);
}
if (status != 0)
fprintf(stdout, "\n\nSome tests FAILED!\n");
return status;
}