mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* bignum.c (bary_pack): Support
INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION flag. Fix byte order and word order handling in code specialized for wordsize % SIZEOF_BDIGITS == 0. * internal.h (INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION): Defined. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@41565 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr
parent
d73b9320cc
commit
8f0c3ff6e4
5 changed files with 189 additions and 139 deletions
|
|
@ -1,3 +1,12 @@
|
|||
Sat Jun 22 18:53:10 2013 Tanaka Akira <akr@fsij.org>
|
||||
|
||||
* bignum.c (bary_pack): Support
|
||||
INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION flag.
|
||||
Fix byte order and word order handling in code specialized for
|
||||
wordsize % SIZEOF_BDIGITS == 0.
|
||||
|
||||
* internal.h (INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION): Defined.
|
||||
|
||||
Sat Jun 22 15:41:25 2013 Koichi Sasada <ko1@atdot.net>
|
||||
|
||||
* gc.c (rgengc_check_shady): add new WB miss checking
|
||||
|
|
|
|||
296
bignum.c
296
bignum.c
|
|
@ -911,7 +911,8 @@ bary_pack(int sign, BDIGIT *ds, size_t num_bdigits, void *words, size_t numwords
|
|||
INTEGER_PACK_MSBYTE_FIRST|
|
||||
INTEGER_PACK_LSBYTE_FIRST|
|
||||
INTEGER_PACK_NATIVE_BYTE_ORDER|
|
||||
INTEGER_PACK_2COMP);
|
||||
INTEGER_PACK_2COMP|
|
||||
INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION);
|
||||
|
||||
while (dp < de && de[-1] == 0)
|
||||
de--;
|
||||
|
|
@ -919,168 +920,185 @@ bary_pack(int sign, BDIGIT *ds, size_t num_bdigits, void *words, size_t numwords
|
|||
sign = 0;
|
||||
}
|
||||
|
||||
if (sign == 0) {
|
||||
MEMZERO(words, unsigned char, numwords * wordsize);
|
||||
return 0;
|
||||
}
|
||||
if (nails == 0 && numwords == 1) {
|
||||
int need_swap = wordsize != 1 &&
|
||||
(flags & INTEGER_PACK_BYTEORDER_MASK) != INTEGER_PACK_NATIVE_BYTE_ORDER &&
|
||||
((flags & INTEGER_PACK_MSBYTE_FIRST) ? !HOST_BIGENDIAN_P : HOST_BIGENDIAN_P);
|
||||
if (0 < sign || !(flags & INTEGER_PACK_2COMP)) {
|
||||
BDIGIT d;
|
||||
if (wordsize == 1) {
|
||||
*((unsigned char *)words) = (unsigned char)(d = dp[0]);
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 8) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
if (!(flags & INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION)) {
|
||||
if (sign == 0) {
|
||||
MEMZERO(words, unsigned char, numwords * wordsize);
|
||||
return 0;
|
||||
}
|
||||
if (nails == 0 && numwords == 1) {
|
||||
int need_swap = wordsize != 1 &&
|
||||
(flags & INTEGER_PACK_BYTEORDER_MASK) != INTEGER_PACK_NATIVE_BYTE_ORDER &&
|
||||
((flags & INTEGER_PACK_MSBYTE_FIRST) ? !HOST_BIGENDIAN_P : HOST_BIGENDIAN_P);
|
||||
if (0 < sign || !(flags & INTEGER_PACK_2COMP)) {
|
||||
BDIGIT d;
|
||||
if (wordsize == 1) {
|
||||
*((unsigned char *)words) = (unsigned char)(d = dp[0]);
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 8) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
#if defined(HAVE_UINT16_T) && 2 <= SIZEOF_BDIGITS
|
||||
if (wordsize == 2 && (uintptr_t)words % ALIGNOF(uint16_t) == 0) {
|
||||
uint16_t u = (uint16_t)(d = dp[0]);
|
||||
if (need_swap) u = swap16(u);
|
||||
*((uint16_t *)words) = u;
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 16) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
if (wordsize == 2 && (uintptr_t)words % ALIGNOF(uint16_t) == 0) {
|
||||
uint16_t u = (uint16_t)(d = dp[0]);
|
||||
if (need_swap) u = swap16(u);
|
||||
*((uint16_t *)words) = u;
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 16) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAVE_UINT32_T) && 4 <= SIZEOF_BDIGITS
|
||||
if (wordsize == 4 && (uintptr_t)words % ALIGNOF(uint32_t) == 0) {
|
||||
uint32_t u = (uint32_t)(d = dp[0]);
|
||||
if (need_swap) u = swap32(u);
|
||||
*((uint32_t *)words) = u;
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 32) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
if (wordsize == 4 && (uintptr_t)words % ALIGNOF(uint32_t) == 0) {
|
||||
uint32_t u = (uint32_t)(d = dp[0]);
|
||||
if (need_swap) u = swap32(u);
|
||||
*((uint32_t *)words) = u;
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 32) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAVE_UINT64_T) && 8 <= SIZEOF_BDIGITS
|
||||
if (wordsize == 8 && (uintptr_t)words % ALIGNOF(uint64_t) == 0) {
|
||||
uint64_t u = (uint64_t)(d = dp[0]);
|
||||
if (need_swap) u = swap64(u);
|
||||
*((uint64_t *)words) = u;
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 64) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
if (wordsize == 8 && (uintptr_t)words % ALIGNOF(uint64_t) == 0) {
|
||||
uint64_t u = (uint64_t)(d = dp[0]);
|
||||
if (need_swap) u = swap64(u);
|
||||
*((uint64_t *)words) = u;
|
||||
return ((1 < de - dp || CLEAR_LOWBITS(d, 64) != 0) ? 2 : 1) * sign;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else { /* sign < 0 && (flags & INTEGER_PACK_2COMP) */
|
||||
BDIGIT_DBL_SIGNED d;
|
||||
if (wordsize == 1) {
|
||||
*((unsigned char *)words) = (unsigned char)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
return (1 < de - dp || FILL_LOWBITS(d, 8) != -1) ? -2 : -1;
|
||||
}
|
||||
else { /* sign < 0 && (flags & INTEGER_PACK_2COMP) */
|
||||
BDIGIT_DBL_SIGNED d;
|
||||
if (wordsize == 1) {
|
||||
*((unsigned char *)words) = (unsigned char)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
return (1 < de - dp || FILL_LOWBITS(d, 8) != -1) ? -2 : -1;
|
||||
}
|
||||
#if defined(HAVE_UINT16_T) && 2 <= SIZEOF_BDIGITS
|
||||
if (wordsize == 2 && (uintptr_t)words % ALIGNOF(uint16_t) == 0) {
|
||||
uint16_t u = (uint16_t)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
if (need_swap) u = swap16(u);
|
||||
*((uint16_t *)words) = u;
|
||||
return (wordsize == SIZEOF_BDIGITS && de - dp == 2 && dp[1] == 1 && dp[0] == 0) ? -1 :
|
||||
(1 < de - dp || FILL_LOWBITS(d, 16) != -1) ? -2 : -1;
|
||||
}
|
||||
if (wordsize == 2 && (uintptr_t)words % ALIGNOF(uint16_t) == 0) {
|
||||
uint16_t u = (uint16_t)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
if (need_swap) u = swap16(u);
|
||||
*((uint16_t *)words) = u;
|
||||
return (wordsize == SIZEOF_BDIGITS && de - dp == 2 && dp[1] == 1 && dp[0] == 0) ? -1 :
|
||||
(1 < de - dp || FILL_LOWBITS(d, 16) != -1) ? -2 : -1;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAVE_UINT32_T) && 4 <= SIZEOF_BDIGITS
|
||||
if (wordsize == 4 && (uintptr_t)words % ALIGNOF(uint32_t) == 0) {
|
||||
uint32_t u = (uint32_t)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
if (need_swap) u = swap32(u);
|
||||
*((uint32_t *)words) = u;
|
||||
return (wordsize == SIZEOF_BDIGITS && de - dp == 2 && dp[1] == 1 && dp[0] == 0) ? -1 :
|
||||
(1 < de - dp || FILL_LOWBITS(d, 32) != -1) ? -2 : -1;
|
||||
}
|
||||
if (wordsize == 4 && (uintptr_t)words % ALIGNOF(uint32_t) == 0) {
|
||||
uint32_t u = (uint32_t)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
if (need_swap) u = swap32(u);
|
||||
*((uint32_t *)words) = u;
|
||||
return (wordsize == SIZEOF_BDIGITS && de - dp == 2 && dp[1] == 1 && dp[0] == 0) ? -1 :
|
||||
(1 < de - dp || FILL_LOWBITS(d, 32) != -1) ? -2 : -1;
|
||||
}
|
||||
#endif
|
||||
#if defined(HAVE_UINT64_T) && 8 <= SIZEOF_BDIGITS
|
||||
if (wordsize == 8 && (uintptr_t)words % ALIGNOF(uint64_t) == 0) {
|
||||
uint64_t u = (uint64_t)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
if (need_swap) u = swap64(u);
|
||||
*((uint64_t *)words) = u;
|
||||
return (wordsize == SIZEOF_BDIGITS && de - dp == 2 && dp[1] == 1 && dp[0] == 0) ? -1 :
|
||||
(1 < de - dp || FILL_LOWBITS(d, 64) != -1) ? -2 : -1;
|
||||
}
|
||||
if (wordsize == 8 && (uintptr_t)words % ALIGNOF(uint64_t) == 0) {
|
||||
uint64_t u = (uint64_t)(d = -(BDIGIT_DBL_SIGNED)dp[0]);
|
||||
if (need_swap) u = swap64(u);
|
||||
*((uint64_t *)words) = u;
|
||||
return (wordsize == SIZEOF_BDIGITS && de - dp == 2 && dp[1] == 1 && dp[0] == 0) ? -1 :
|
||||
(1 < de - dp || FILL_LOWBITS(d, 64) != -1) ? -2 : -1;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
#if !defined(WORDS_BIGENDIAN)
|
||||
if (nails == 0 && SIZEOF_BDIGITS == sizeof(BDIGIT) &&
|
||||
(flags & INTEGER_PACK_WORDORDER_MASK) == INTEGER_PACK_LSWORD_FIRST &&
|
||||
(flags & INTEGER_PACK_BYTEORDER_MASK) != INTEGER_PACK_MSBYTE_FIRST) {
|
||||
size_t src_size = num_bdigits * SIZEOF_BDIGITS;
|
||||
size_t dst_size = numwords * wordsize;
|
||||
int overflow = 0;
|
||||
while (0 < src_size && ((unsigned char *)ds)[src_size-1] == 0)
|
||||
src_size--;
|
||||
if (src_size <= dst_size) {
|
||||
MEMCPY(words, dp, char, src_size);
|
||||
MEMZERO((char*)words + src_size, char, dst_size - src_size);
|
||||
}
|
||||
else {
|
||||
MEMCPY(words, dp, char, dst_size);
|
||||
overflow = 1;
|
||||
}
|
||||
if (sign < 0 && (flags & INTEGER_PACK_2COMP)) {
|
||||
unsigned char *p = words, *e = (unsigned char *)words + dst_size;
|
||||
while (p < e && *p == 0)
|
||||
p++;
|
||||
if (p < e) {
|
||||
*p = 1 + (unsigned char)~*p;
|
||||
p++;
|
||||
while (p < e) {
|
||||
*p = (unsigned char)~*p;
|
||||
if (nails == 0 && SIZEOF_BDIGITS == sizeof(BDIGIT) &&
|
||||
(flags & INTEGER_PACK_WORDORDER_MASK) == INTEGER_PACK_LSWORD_FIRST &&
|
||||
(flags & INTEGER_PACK_BYTEORDER_MASK) != INTEGER_PACK_MSBYTE_FIRST) {
|
||||
size_t src_size = num_bdigits * SIZEOF_BDIGITS;
|
||||
size_t dst_size = numwords * wordsize;
|
||||
int overflow = 0;
|
||||
while (0 < src_size && ((unsigned char *)ds)[src_size-1] == 0)
|
||||
src_size--;
|
||||
if (src_size <= dst_size) {
|
||||
MEMCPY(words, dp, char, src_size);
|
||||
MEMZERO((char*)words + src_size, char, dst_size - src_size);
|
||||
}
|
||||
else {
|
||||
MEMCPY(words, dp, char, dst_size);
|
||||
overflow = 1;
|
||||
}
|
||||
if (sign < 0 && (flags & INTEGER_PACK_2COMP)) {
|
||||
unsigned char *p = words, *e = (unsigned char *)words + dst_size;
|
||||
while (p < e && *p == 0)
|
||||
p++;
|
||||
}
|
||||
}
|
||||
else if (overflow) {
|
||||
p = (unsigned char *)dp + dst_size;
|
||||
e = (unsigned char *)dp + src_size;
|
||||
if (p < e && *p++ == 1) {
|
||||
while (p < e && *p == 0)
|
||||
if (p < e) {
|
||||
*p = 1 + (unsigned char)~*p;
|
||||
p++;
|
||||
while (p < e) {
|
||||
*p = (unsigned char)~*p;
|
||||
p++;
|
||||
if (p == e)
|
||||
overflow = 0;
|
||||
}
|
||||
}
|
||||
else if (overflow) {
|
||||
p = (unsigned char *)dp + dst_size;
|
||||
e = (unsigned char *)dp + src_size;
|
||||
if (p < e && *p++ == 1) {
|
||||
while (p < e && *p == 0)
|
||||
p++;
|
||||
if (p == e)
|
||||
overflow = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (overflow)
|
||||
sign *= 2;
|
||||
return sign;
|
||||
}
|
||||
if (overflow)
|
||||
sign *= 2;
|
||||
return sign;
|
||||
}
|
||||
#endif
|
||||
if (nails == 0 && SIZEOF_BDIGITS == sizeof(BDIGIT) &&
|
||||
wordsize % SIZEOF_BDIGITS == 0 && (uintptr_t)words % ALIGNOF(BDIGIT) == 0) {
|
||||
size_t buf_num_bdigits = numwords * wordsize / SIZEOF_BDIGITS;
|
||||
int need_swap =
|
||||
(flags & INTEGER_PACK_BYTEORDER_MASK) != INTEGER_PACK_NATIVE_BYTE_ORDER &&
|
||||
((flags & INTEGER_PACK_MSBYTE_FIRST) ? !HOST_BIGENDIAN_P : HOST_BIGENDIAN_P);
|
||||
size_t i;
|
||||
int overflow = 0;
|
||||
if (num_bdigits <= buf_num_bdigits) {
|
||||
MEMCPY(words, dp, BDIGIT, num_bdigits);
|
||||
MEMZERO((BDIGIT*)words + num_bdigits, BDIGIT, buf_num_bdigits - num_bdigits);
|
||||
}
|
||||
else {
|
||||
MEMCPY(words, dp, BDIGIT, buf_num_bdigits);
|
||||
overflow = 1;
|
||||
}
|
||||
if (sign < 0 && (flags & INTEGER_PACK_2COMP)) {
|
||||
int zero_p = bary_2comp(words, buf_num_bdigits);
|
||||
if (overflow &&
|
||||
buf_num_bdigits == num_bdigits-1 &&
|
||||
dp[buf_num_bdigits] == 1 &&
|
||||
zero_p)
|
||||
overflow = 0;
|
||||
}
|
||||
if (need_swap) {
|
||||
for (i = 0; i < buf_num_bdigits; i++) {
|
||||
BDIGIT d = ((BDIGIT*)words)[i];
|
||||
((BDIGIT*)words)[i] = swap_bdigit(d);
|
||||
if (nails == 0 && SIZEOF_BDIGITS == sizeof(BDIGIT) &&
|
||||
wordsize % SIZEOF_BDIGITS == 0 && (uintptr_t)words % ALIGNOF(BDIGIT) == 0) {
|
||||
size_t buf_num_bdigits = numwords * wordsize / SIZEOF_BDIGITS;
|
||||
int overflow = 0;
|
||||
int mswordfirst_p = (flags & INTEGER_PACK_MSWORD_FIRST) != 0;
|
||||
int msbytefirst_p = (flags & INTEGER_PACK_NATIVE_BYTE_ORDER) ? HOST_BIGENDIAN_P :
|
||||
(flags & INTEGER_PACK_MSBYTE_FIRST) != 0;
|
||||
if (num_bdigits <= buf_num_bdigits) {
|
||||
MEMCPY(words, dp, BDIGIT, num_bdigits);
|
||||
MEMZERO((BDIGIT*)words + num_bdigits, BDIGIT, buf_num_bdigits - num_bdigits);
|
||||
}
|
||||
}
|
||||
if (flags & INTEGER_PACK_MSWORD_FIRST) {
|
||||
BDIGIT *p1 = words, *p2 = p1 + buf_num_bdigits - 1;
|
||||
while (p1 < p2) {
|
||||
BDIGIT tmp = *p1;
|
||||
*p1 = *p2;
|
||||
*p2 = tmp;
|
||||
p1++;
|
||||
p2--;
|
||||
else {
|
||||
MEMCPY(words, dp, BDIGIT, buf_num_bdigits);
|
||||
overflow = 1;
|
||||
}
|
||||
if (sign < 0 && (flags & INTEGER_PACK_2COMP)) {
|
||||
int zero_p = bary_2comp(words, buf_num_bdigits);
|
||||
if (overflow &&
|
||||
buf_num_bdigits == num_bdigits-1 &&
|
||||
dp[buf_num_bdigits] == 1 &&
|
||||
zero_p)
|
||||
overflow = 0;
|
||||
}
|
||||
if (msbytefirst_p != HOST_BIGENDIAN_P) {
|
||||
size_t i;
|
||||
for (i = 0; i < buf_num_bdigits; i++) {
|
||||
BDIGIT d = ((BDIGIT*)words)[i];
|
||||
((BDIGIT*)words)[i] = swap_bdigit(d);
|
||||
}
|
||||
}
|
||||
if (mswordfirst_p ? !msbytefirst_p : msbytefirst_p) {
|
||||
size_t i;
|
||||
BDIGIT *p = words;
|
||||
for (i = 0; i < numwords; i++) {
|
||||
BDIGIT *p1 = p, *p2 = p1 + wordsize/SIZEOF_BDIGITS - 1;
|
||||
while (p1 < p2) {
|
||||
BDIGIT tmp = *p1;
|
||||
*p1 = *p2;
|
||||
*p2 = tmp;
|
||||
p1++;
|
||||
p2--;
|
||||
}
|
||||
p += wordsize/SIZEOF_BDIGITS;
|
||||
}
|
||||
}
|
||||
if (mswordfirst_p) {
|
||||
BDIGIT *p1 = words, *p2 = p1 + buf_num_bdigits - 1;
|
||||
while (p1 < p2) {
|
||||
BDIGIT tmp = *p1;
|
||||
*p1 = *p2;
|
||||
*p2 = tmp;
|
||||
p1++;
|
||||
p2--;
|
||||
}
|
||||
}
|
||||
if (overflow)
|
||||
sign *= 2;
|
||||
return sign;
|
||||
}
|
||||
if (overflow)
|
||||
sign *= 2;
|
||||
return sign;
|
||||
}
|
||||
|
||||
buf = words;
|
||||
|
|
|
|||
|
|
@ -61,4 +61,5 @@ Init_pack(VALUE klass)
|
|||
rb_define_const(rb_cInteger, "INTEGER_PACK_BIG_ENDIAN", INT2NUM(INTEGER_PACK_BIG_ENDIAN));
|
||||
rb_define_const(rb_cInteger, "INTEGER_PACK_FORCE_BIGNUM", INT2NUM(INTEGER_PACK_FORCE_BIGNUM));
|
||||
rb_define_const(rb_cInteger, "INTEGER_PACK_NEGATIVE", INT2NUM(INTEGER_PACK_NEGATIVE));
|
||||
rb_define_const(rb_cInteger, "INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION", INT2NUM(INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -62,6 +62,7 @@ extern "C" {
|
|||
#define INTEGER_PACK_LSBYTE_FIRST 0x20
|
||||
#define INTEGER_PACK_NATIVE_BYTE_ORDER 0x40
|
||||
#define INTEGER_PACK_2COMP 0x80
|
||||
#define INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION 0x400
|
||||
/* For rb_integer_unpack: */
|
||||
#define INTEGER_PACK_FORCE_BIGNUM 0x100
|
||||
#define INTEGER_PACK_NEGATIVE 0x200
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@ class TestBignum < Test::Unit::TestCase
|
|||
LITTLE_ENDIAN = Integer::INTEGER_PACK_LITTLE_ENDIAN
|
||||
BIG_ENDIAN = Integer::INTEGER_PACK_BIG_ENDIAN
|
||||
NEGATIVE = Integer::INTEGER_PACK_NEGATIVE
|
||||
GENERIC = Integer::INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION
|
||||
|
||||
def test_pack_zero
|
||||
assert_equal([0, ""], 0.test_pack(0, 1, 0, BIG_ENDIAN))
|
||||
|
|
@ -123,6 +124,25 @@ class TestBignum < Test::Unit::TestCase
|
|||
assert_equal([-1, "\x80\x70\x60\x50\x40\x30\x20\x10"], (-0x8070605040302010).test_pack(8, 1, 0, BIG_ENDIAN))
|
||||
end
|
||||
|
||||
def test_pack_orders
|
||||
[MSWORD_FIRST, LSWORD_FIRST].each {|word_order|
|
||||
[MSBYTE_FIRST, LSBYTE_FIRST, NATIVE_BYTE_ORDER].each {|byte_order|
|
||||
1.upto(16) {|wordsize|
|
||||
1.upto(20) {|numwords|
|
||||
w = numwords*wordsize
|
||||
n = 0;
|
||||
0.upto(w) {|i|
|
||||
n |= ((i+1) % 256) << (i*8)
|
||||
}
|
||||
assert_equal(n.test_pack(numwords, wordsize, 0, word_order|byte_order|GENERIC),
|
||||
n.test_pack(numwords, wordsize, 0, word_order|byte_order),
|
||||
"#{'%#x' % n}.test_pack(#{numwords}, #{wordsize}, 0, #{'%#x' % (word_order|byte_order)})")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
end
|
||||
|
||||
def test_pack2comp_zero
|
||||
assert_equal([0, ""], 0.test_pack(0, 1, 0, TWOCOMP|BIG_ENDIAN))
|
||||
end
|
||||
|
|
@ -273,6 +293,7 @@ class TestBignum < Test::Unit::TestCase
|
|||
def test_unpack2comp_negative_zero
|
||||
0.upto(100) {|n|
|
||||
assert_equal(-(256**n), Integer.test_unpack("\x00"*n, n, 1, 0, TWOCOMP|BIG_ENDIAN|NEGATIVE))
|
||||
assert_equal(-(256**n), Integer.test_unpack("\x00"*n, n, 1, 0, TWOCOMP|LITTLE_ENDIAN|NEGATIVE))
|
||||
}
|
||||
end
|
||||
end
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue