Skip to content

Commit 7306dfb

Browse files
camgunzcamgunz
committed
Allow unsigned C-datatype functions to read signed types so long as they're not
 negative Add some more tests for C-datatype functions
1 parent f2201e5 commit 7306dfb

File tree

3 files changed

+199
-24
lines changed

3 files changed

+199
-24
lines changed

‎.travis.yml

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,6 @@ before_install:
1616
- pip install --user cpp-coveralls
1717

1818
script:
19-
- make test
2019
- make test2
2120

2221
after_success:

‎cmp.c

Lines changed: 95 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1847,10 +1847,13 @@ bool cmp_read_short(cmp_ctx_t *ctx, int16_t *s) {
18471847
*s = obj.as.u16;
18481848
return true;
18491849
}
1850+
break;
18501851
default:
1851-
ctx->error = INVALID_TYPE_ERROR;
1852-
return false;
1852+
break;
18531853
}
1854+
1855+
ctx->error = INVALID_TYPE_ERROR;
1856+
return false;
18541857
}
18551858

18561859
bool cmp_read_int(cmp_ctx_t *ctx, int32_t *i) {
@@ -1882,10 +1885,13 @@ bool cmp_read_int(cmp_ctx_t *ctx, int32_t *i) {
18821885
*i = obj.as.u32;
18831886
return true;
18841887
}
1888+
break;
18851889
default:
1886-
ctx->error = INVALID_TYPE_ERROR;
1887-
return false;
1890+
break;
18881891
}
1892+
1893+
ctx->error = INVALID_TYPE_ERROR;
1894+
return false;
18891895
}
18901896

18911897
bool cmp_read_long(cmp_ctx_t *ctx, int64_t *d) {
@@ -1923,10 +1929,13 @@ bool cmp_read_long(cmp_ctx_t *ctx, int64_t *d) {
19231929
*d = obj.as.u64;
19241930
return true;
19251931
}
1932+
break;
19261933
default:
1927-
ctx->error = INVALID_TYPE_ERROR;
1928-
return false;
1934+
break;
19291935
}
1936+
1937+
ctx->error = INVALID_TYPE_ERROR;
1938+
return false;
19301939
}
19311940

19321941
bool cmp_read_integer(cmp_ctx_t *ctx, int64_t *d) {
@@ -2008,10 +2017,19 @@ bool cmp_read_uchar(cmp_ctx_t *ctx, uint8_t *c) {
20082017
case CMP_TYPE_UINT8:
20092018
*c = obj.as.u8;
20102019
return true;
2020+
case CMP_TYPE_NEGATIVE_FIXNUM:
2021+
case CMP_TYPE_SINT8:
2022+
if (obj.as.s8 >= 0) {
2023+
*c = obj.as.s8;
2024+
return true;
2025+
}
2026+
break;
20112027
default:
2012-
ctx->error = INVALID_TYPE_ERROR;
2013-
return false;
2028+
break;
20142029
}
2030+
2031+
ctx->error = INVALID_TYPE_ERROR;
2032+
return false;
20152033
}
20162034

20172035
bool cmp_read_ushort(cmp_ctx_t *ctx, uint16_t *s) {
@@ -2028,10 +2046,25 @@ bool cmp_read_ushort(cmp_ctx_t *ctx, uint16_t *s) {
20282046
case CMP_TYPE_UINT16:
20292047
*s = obj.as.u16;
20302048
return true;
2049+
case CMP_TYPE_NEGATIVE_FIXNUM:
2050+
case CMP_TYPE_SINT8:
2051+
if (obj.as.s8 >= 0) {
2052+
*s = obj.as.s8;
2053+
return true;
2054+
}
2055+
break;
2056+
case CMP_TYPE_SINT16:
2057+
if (obj.as.s16 >= 0) {
2058+
*s = obj.as.s16;
2059+
return true;
2060+
}
2061+
break;
20312062
default:
2032-
ctx->error = INVALID_TYPE_ERROR;
2033-
return false;
2063+
break;
20342064
}
2065+
2066+
ctx->error = INVALID_TYPE_ERROR;
2067+
return false;
20352068
}
20362069

20372070
bool cmp_read_uint(cmp_ctx_t *ctx, uint32_t *i) {
@@ -2051,10 +2084,31 @@ bool cmp_read_uint(cmp_ctx_t *ctx, uint32_t *i) {
20512084
case CMP_TYPE_UINT32:
20522085
*i = obj.as.u32;
20532086
return true;
2087+
case CMP_TYPE_NEGATIVE_FIXNUM:
2088+
case CMP_TYPE_SINT8:
2089+
if (obj.as.s8 >= 0) {
2090+
*i = obj.as.s8;
2091+
return true;
2092+
}
2093+
break;
2094+
case CMP_TYPE_SINT16:
2095+
if (obj.as.s16 >= 0) {
2096+
*i = obj.as.s16;
2097+
return true;
2098+
}
2099+
break;
2100+
case CMP_TYPE_SINT32:
2101+
if (obj.as.s32 >= 0) {
2102+
*i = obj.as.s32;
2103+
return true;
2104+
}
2105+
break;
20542106
default:
2055-
ctx->error = INVALID_TYPE_ERROR;
2056-
return false;
2107+
break;
20572108
}
2109+
2110+
ctx->error = INVALID_TYPE_ERROR;
2111+
return false;
20582112
}
20592113

20602114
bool cmp_read_ulong(cmp_ctx_t *ctx, uint64_t *u) {
@@ -2077,10 +2131,37 @@ bool cmp_read_ulong(cmp_ctx_t *ctx, uint64_t *u) {
20772131
case CMP_TYPE_UINT64:
20782132
*u = obj.as.u64;
20792133
return true;
2134+
case CMP_TYPE_NEGATIVE_FIXNUM:
2135+
case CMP_TYPE_SINT8:
2136+
if (obj.as.s8 >= 0) {
2137+
*u = obj.as.s8;
2138+
return true;
2139+
}
2140+
break;
2141+
case CMP_TYPE_SINT16:
2142+
if (obj.as.s16 >= 0) {
2143+
*u = obj.as.s16;
2144+
return true;
2145+
}
2146+
break;
2147+
case CMP_TYPE_SINT32:
2148+
if (obj.as.s32 >= 0) {
2149+
*u = obj.as.s32;
2150+
return true;
2151+
}
2152+
break;
2153+
case CMP_TYPE_SINT64:
2154+
if (obj.as.s64 >= 0) {
2155+
*u = obj.as.s64;
2156+
return true;
2157+
}
2158+
break;
20802159
default:
2081-
ctx->error = INVALID_TYPE_ERROR;
2082-
return false;
2160+
break;
20832161
}
2162+
2163+
ctx->error = INVALID_TYPE_ERROR;
2164+
return false;
20842165
}
20852166

20862167
bool cmp_read_uinteger(cmp_ctx_t *ctx, uint64_t *d) {

‎test/test2.c

Lines changed: 104 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1969,35 +1969,130 @@ static void test_numbers(void **state) {
19691969
assert_true(cmp_read_double(&cmp, &d));
19701970

19711971
M_BufferClear(&buf);
1972+
assert_true(cmp_write_u8(&cmp, 1));
19721973
assert_true(cmp_write_s8(&cmp, -1));
19731974
assert_true(cmp_write_s8(&cmp, -100));
19741975
assert_true(cmp_write_s8(&cmp, 100));
1975-
assert_true(cmp_write_s16(&cmp, -200));
1976-
assert_true(cmp_write_s32(&cmp, -33000));
1977-
assert_true(cmp_write_s64(&cmp, 0xFFFFFFFFF));
1978-
assert_true(cmp_write_u8(&cmp, 1));
19791976
assert_true(cmp_write_u8(&cmp, 200));
1977+
assert_true(cmp_write_s16(&cmp, -200));
19801978
assert_true(cmp_write_u16(&cmp, 300));
1981-
assert_true(cmp_write_u32(&cmp, 70000));
1982-
assert_true(cmp_write_u64(&cmp, 0xFFFFFFFFF));
1979+
assert_true(cmp_write_u16(&cmp, 33000));
1980+
assert_true(cmp_write_s32(&cmp, -33000));
1981+
assert_true(cmp_write_u32(&cmp, 33000));
1982+
assert_true(cmp_write_u32(&cmp, 0x81000000));
1983+
assert_true(cmp_write_s64(&cmp, 0xFFFFFFFFFFFFFFFC));
1984+
assert_true(cmp_write_s64(&cmp, 0x7FFFFFFFFFFFFFFC));
1985+
assert_true(cmp_write_u64(&cmp, 0x800000000000000C));
19831986
assert_true(cmp_write_decimal(&cmp, 1.1f));
19841987
assert_true(cmp_write_decimal(&cmp, 1.1));
19851988

19861989
M_BufferSeek(&buf, 0);
19871990
assert_true(cmp_read_char(&cmp, &s8));
19881991
assert_true(cmp_read_char(&cmp, &s8));
19891992
assert_true(cmp_read_char(&cmp, &s8));
1990-
assert_true(cmp_read_short(&cmp, &s16));
1991-
assert_true(cmp_read_int(&cmp, &s32));
1992-
assert_true(cmp_read_long(&cmp, &s64));
1993+
assert_true(cmp_read_char(&cmp, &s8));
1994+
1995+
M_BufferSeek(&buf, 0);
1996+
assert_true(cmp_read_uchar(&cmp, &u8));
1997+
assert_true(cmp_read_char(&cmp, &s8));
1998+
assert_true(cmp_read_char(&cmp, &s8));
19931999
assert_true(cmp_read_uchar(&cmp, &u8));
19942000
assert_true(cmp_read_uchar(&cmp, &u8));
2001+
2002+
M_BufferSeek(&buf, 0);
2003+
assert_true(cmp_read_short(&cmp, &s16));
2004+
assert_true(cmp_read_short(&cmp, &s16));
2005+
assert_true(cmp_read_short(&cmp, &s16));
2006+
assert_true(cmp_read_short(&cmp, &s16));
2007+
assert_true(cmp_read_short(&cmp, &s16));
2008+
assert_true(cmp_read_short(&cmp, &s16));
2009+
assert_true(cmp_read_short(&cmp, &s16));
2010+
2011+
M_BufferSeek(&buf, 0);
2012+
assert_true(cmp_read_ushort(&cmp, &u16));
2013+
assert_true(cmp_read_short(&cmp, &s16));
2014+
assert_true(cmp_read_short(&cmp, &s16));
2015+
assert_true(cmp_read_ushort(&cmp, &u16));
2016+
assert_true(cmp_read_ushort(&cmp, &u16));
2017+
assert_true(cmp_read_short(&cmp, &s16));
2018+
assert_true(cmp_read_ushort(&cmp, &u16));
19952019
assert_true(cmp_read_ushort(&cmp, &u16));
2020+
2021+
M_BufferSeek(&buf, 0);
2022+
assert_true(cmp_read_int(&cmp, &s32));
2023+
assert_true(cmp_read_int(&cmp, &s32));
2024+
assert_true(cmp_read_int(&cmp, &s32));
2025+
assert_true(cmp_read_int(&cmp, &s32));
2026+
assert_true(cmp_read_int(&cmp, &s32));
2027+
assert_true(cmp_read_int(&cmp, &s32));
2028+
assert_true(cmp_read_int(&cmp, &s32));
2029+
assert_true(cmp_read_int(&cmp, &s32));
2030+
assert_true(cmp_read_int(&cmp, &s32));
2031+
assert_true(cmp_read_int(&cmp, &s32));
2032+
2033+
M_BufferSeek(&buf, 0);
2034+
assert_true(cmp_read_uint(&cmp, &u32));
2035+
assert_true(cmp_read_int(&cmp, &s32));
2036+
assert_true(cmp_read_int(&cmp, &s32));
2037+
assert_true(cmp_read_uint(&cmp, &u32));
2038+
assert_true(cmp_read_uint(&cmp, &u32));
2039+
assert_true(cmp_read_int(&cmp, &s32));
2040+
assert_true(cmp_read_uint(&cmp, &u32));
2041+
assert_true(cmp_read_uint(&cmp, &u32));
2042+
assert_true(cmp_read_int(&cmp, &s32));
2043+
assert_true(cmp_read_uint(&cmp, &u32));
19962044
assert_true(cmp_read_uint(&cmp, &u32));
2045+
2046+
M_BufferSeek(&buf, 0);
2047+
assert_true(cmp_read_long(&cmp, &s64));
2048+
assert_true(cmp_read_long(&cmp, &s64));
2049+
assert_true(cmp_read_long(&cmp, &s64));
2050+
assert_true(cmp_read_long(&cmp, &s64));
2051+
assert_true(cmp_read_long(&cmp, &s64));
2052+
assert_true(cmp_read_long(&cmp, &s64));
2053+
assert_true(cmp_read_long(&cmp, &s64));
2054+
assert_true(cmp_read_long(&cmp, &s64));
2055+
assert_true(cmp_read_long(&cmp, &s64));
2056+
assert_true(cmp_read_long(&cmp, &s64));
2057+
assert_true(cmp_read_long(&cmp, &s64));
2058+
assert_true(cmp_read_long(&cmp, &s64));
2059+
assert_true(cmp_read_long(&cmp, &s64));
2060+
2061+
M_BufferSeek(&buf, 0);
2062+
assert_true(cmp_read_ulong(&cmp, &u64));
2063+
assert_true(cmp_read_long(&cmp, &s64));
2064+
assert_true(cmp_read_long(&cmp, &s64));
2065+
assert_true(cmp_read_ulong(&cmp, &u64));
2066+
assert_true(cmp_read_ulong(&cmp, &u64));
2067+
assert_true(cmp_read_long(&cmp, &s64));
2068+
assert_true(cmp_read_ulong(&cmp, &u64));
2069+
assert_true(cmp_read_ulong(&cmp, &u64));
2070+
assert_true(cmp_read_long(&cmp, &s64));
2071+
assert_true(cmp_read_ulong(&cmp, &u64));
2072+
assert_true(cmp_read_ulong(&cmp, &u64));
2073+
assert_true(cmp_read_long(&cmp, &s64));
2074+
assert_true(cmp_read_ulong(&cmp, &u64));
19972075
assert_true(cmp_read_ulong(&cmp, &u64));
2076+
19982077
assert_true(cmp_read_decimal(&cmp, &d));
19992078
assert_true(cmp_read_decimal(&cmp, &d));
20002079

2080+
M_BufferSeek(&buf, 0);
2081+
reader_successes = 0;
2082+
assert_false(cmp_read_char(&cmp, &s8));
2083+
assert_false(cmp_read_char(&cmp, &s8));
2084+
assert_false(cmp_read_char(&cmp, &s8));
2085+
assert_false(cmp_read_short(&cmp, &s16));
2086+
assert_false(cmp_read_int(&cmp, &s32));
2087+
assert_false(cmp_read_long(&cmp, &s64));
2088+
assert_false(cmp_read_uchar(&cmp, &u8));
2089+
assert_false(cmp_read_uchar(&cmp, &u8));
2090+
assert_false(cmp_read_ushort(&cmp, &u16));
2091+
assert_false(cmp_read_uint(&cmp, &u32));
2092+
assert_false(cmp_read_ulong(&cmp, &u64));
2093+
assert_false(cmp_read_decimal(&cmp, &d));
2094+
assert_false(cmp_read_decimal(&cmp, &d));
2095+
20012096
M_BufferClear(&buf);
20022097
assert_true(cmp_write_u8(&cmp, 200));
20032098
M_BufferSeek(&buf, 0);

0 commit comments

Comments
 (0)