Reorganize `Integer` system.

- Integrate `Fixnum` and `Integer`
- Remove `Integral`
- `int / int -> int`
- Replace `mrb_fixnum()` to `mrb_int()`
- Replace `mrb_fixnum_value()` to `mrb_int_value()`.
- Use `mrb_integer_p()` instead of `mrb_fixnum_p()`

16 files changed, 74 insertions, 76 deletions

diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index 72ae0a3a9..2e39817ec 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -545,7 +545,7 @@ new_lit(codegen_scope *s, mrb_value val)
 #endif
   case MRB_TT_INTEGER:
     for (i=0; i<s->irep->plen; i++) {
-      mrb_int v = mrb_fixnum(val);
+      mrb_int v = mrb_integer(val);
       pv = &s->pool[i];
       if (pv->tt == IREP_TT_INT32) {
         if (v == pv->u.i32) return i;
@@ -597,10 +597,10 @@ new_lit(codegen_scope *s, mrb_value val)
   case MRB_TT_INTEGER:
 #ifdef MRB_INT64
     pv->tt = IREP_TT_INT64;
-    pv->u.i64 = mrb_fixnum(val);
+    pv->u.i64 = mrb_integer(val);
 #else
     pv->tt = IREP_TT_INT32;
-    pv->u.i32 = mrb_fixnum(val);
+    pv->u.i32 = mrb_integer(val);
 #endif
     break;
 
diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb
index ecd6c4d65..26d5766fc 100644
--- a/mrbgems/mruby-enumerator/test/enumerator.rb
+++ b/mrbgems/mruby-enumerator/test/enumerator.rb
@@ -445,7 +445,7 @@ assert 'modifying existing methods' do
   }
 end
 
-assert 'Integral#times' do
+assert 'Integer#times' do
   a = 3
   b = a.times
   c = []
diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c
index b4d9b1f1e..6764b1af4 100644
--- a/mrbgems/mruby-inline-struct/test/inline.c
+++ b/mrbgems/mruby-inline-struct/test/inline.c
@@ -10,7 +10,7 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self)
   mrb_int size = mrb_istruct_size();
   mrb_value object = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(object)) {
+  if (mrb_integer_p(object)) {
     strncpy(string, "fixnum", size-1);
   }
 #ifndef MRB_NO_FLOAT
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
index 712fea79c..97bff31b4 100644
--- a/mrbgems/mruby-io/src/io.c
+++ b/mrbgems/mruby-io/src/io.c
@@ -339,7 +339,7 @@ option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
     case MRB_TT_DATA: /* IO */
       return mrb_io_fileno(mrb, opt);
     case MRB_TT_INTEGER:
-      return (int)mrb_fixnum(opt);
+      return (int)mrb_integer(opt);
     default:
       mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
       break;
@@ -1077,7 +1077,7 @@ time2timeval(mrb_state *mrb, mrb_value time)
 
   switch (mrb_type(time)) {
     case MRB_TT_INTEGER:
-      t.tv_sec = (ftime_t)mrb_fixnum(time);
+      t.tv_sec = (ftime_t)mrb_integer(time);
       t.tv_usec = 0;
       break;
 
diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
index d00be4b5d..e5ec90866 100644
--- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c
+++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
@@ -53,7 +53,7 @@ mrb_int_nobits(mrb_state *mrb, mrb_value self)
 void
 mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
 {
-  struct RClass *i = mrb_module_get(mrb, "Integral");
+  struct RClass *i = mrb_class_get(mrb, "Integer");
 
   mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c
index f797b599b..35e79d25d 100644
--- a/mrbgems/mruby-pack/src/pack.c
+++ b/mrbgems/mruby-pack/src/pack.c
@@ -143,7 +143,7 @@ static int
 pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
 {
   str = str_len_ensure(mrb, str, sidx + 1);
-  RSTRING_PTR(str)[sidx] = (char)mrb_fixnum(o);
+  RSTRING_PTR(str)[sidx] = (char)mrb_integer(o);
   return 1;
 }
 
@@ -163,7 +163,7 @@ pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint16_t n;
 
   str = str_len_ensure(mrb, str, sidx + 2);
-  n = (uint16_t)mrb_fixnum(o);
+  n = (uint16_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = n % 256;
     RSTRING_PTR(str)[sidx+1] = n / 256;
@@ -197,7 +197,7 @@ pack_l(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint32_t n;
 
   str = str_len_ensure(mrb, str, sidx + 4);
-  n = (uint32_t)mrb_fixnum(o);
+  n = (uint32_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
     RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -313,7 +313,7 @@ pack_q(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint64_t n;
 
   str = str_len_ensure(mrb, str, sidx + 8);
-  n = (uint64_t)mrb_fixnum(o);
+  n = (uint64_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
     RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -560,7 +560,7 @@ pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, long count,
   int len = 0;
   uint32_t c = 0;
 
-  c = (uint32_t)mrb_fixnum(o);
+  c = (uint32_t)mrb_integer(o);
 
   /* Unicode character */
   /* from mruby-compiler gem */
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index 39c72ac9e..5fa15c508 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -93,7 +93,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
 {
   mrb_value value;
 
-  if (mrb_fixnum(max) == 0) {
+  if (mrb_integer(max) == 0) {
 #ifndef MRB_NO_FLOAT
     value = mrb_float_value(mrb, rand_real(t));
 #else
@@ -101,7 +101,7 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
 #endif
   }
   else {
-    value = mrb_fixnum_value(rand_uint32(t) % mrb_fixnum(max));
+    value = mrb_fixnum_value(rand_uint32(t) % mrb_integer(max));
   }
 
   return value;
@@ -119,7 +119,7 @@ get_opt(mrb_state* mrb)
     mrb_int i;
 
     arg = mrb_to_int(mrb, arg);
-    i = mrb_fixnum(arg);
+    i = mrb_integer(arg);
     if (i < 0) {
       arg = mrb_fixnum_value(0 - i);
     }
@@ -161,7 +161,7 @@ random_m_init(mrb_state *mrb, mrb_value self)
     rand_init(t);
   }
   else {
-    rand_seed(t, (uint32_t)mrb_fixnum(seed));
+    rand_seed(t, (uint32_t)mrb_integer(seed));
   }
 
   return self;
@@ -190,7 +190,7 @@ random_m_srand(mrb_state *mrb, mrb_value self)
     seed = (uint32_t)time(NULL) + rand_uint32(t);
   }
   else {
-    seed = (uint32_t)mrb_fixnum(sv);
+    seed = (uint32_t)mrb_integer(sv);
   }
   old_seed = rand_seed(t, seed);
 
@@ -257,7 +257,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
       mrb_value *ptr = RARRAY_PTR(ary);
       mrb_value tmp;
 
-      j = mrb_fixnum(random_rand(mrb, random, max));
+      j = mrb_integer(random_rand(mrb, random, max));
 
       tmp = ptr[i];
       ptr[i] = ptr[j];
@@ -342,7 +342,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
         r = (mrb_int)(rand_uint32(random) % len);
 
         for (j=0; j<i; j++) {
-          if (mrb_fixnum(RARRAY_PTR(result)[j]) == r) {
+          if (mrb_integer(RARRAY_PTR(result)[j]) == r) {
             goto retry;         /* retry if duplicate */
           }
         }
@@ -351,7 +351,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
       mrb_ary_push(mrb, result, mrb_fixnum_value(r));
     }
     for (i=0; i<n; i++) {
-      mrb_int idx = mrb_fixnum(RARRAY_PTR(result)[i]);
+      mrb_int idx = mrb_integer(RARRAY_PTR(result)[i]);
       mrb_value elem = RARRAY_PTR(ary)[idx];
       mrb_ary_set(mrb, result, i, elem);
     }
diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c
index 421e7d33a..0f2cc6119 100644
--- a/mrbgems/mruby-range-ext/src/range.c
+++ b/mrbgems/mruby-range-ext/src/range.c
@@ -109,8 +109,8 @@ range_size(mrb_state *mrb, mrb_value range)
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
   excl = RANGE_EXCL(r);
-  if (mrb_fixnum_p(beg)) {
-    beg_f = (mrb_float)mrb_fixnum(beg);
+  if (mrb_integer_p(beg)) {
+    beg_f = (mrb_float)mrb_integer(beg);
   }
   else if (mrb_float_p(beg)) {
     beg_f = mrb_float(beg);
@@ -118,8 +118,8 @@ range_size(mrb_state *mrb, mrb_value range)
   else {
     num_p = FALSE;
   }
-  if (mrb_fixnum_p(end)) {
-    end_f = (mrb_float)mrb_fixnum(end);
+  if (mrb_integer_p(end)) {
+    end_f = (mrb_float)mrb_integer(end);
   }
   else if (mrb_float_p(end)) {
     end_f = mrb_float(end);
@@ -161,9 +161,9 @@ range_size(mrb_state *mrb, mrb_value range)
   end = RANGE_END(r);
   excl = RANGE_EXCL(r) ? 0 : 1;
 
-  if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
-    mrb_int a = mrb_fixnum(beg);
-    mrb_int b = mrb_fixnum(end);
+  if (mrb_integer_p(beg) && mrb_integer_p(end)) {
+    mrb_int a = mrb_integer(beg);
+    mrb_int b = mrb_integer(end);
     mrb_int c = b - a + excl;
 
     return mrb_fixnum_value(c);
diff --git a/mrbgems/mruby-rational/mrblib/rational.rb b/mrbgems/mruby-rational/mrblib/rational.rb
index 489d89ebd..e401b1bd6 100644
--- a/mrbgems/mruby-rational/mrblib/rational.rb
+++ b/mrbgems/mruby-rational/mrblib/rational.rb
@@ -48,11 +48,11 @@ class Rational < Numeric
   end
 
   def <=>(rhs)
-    if rhs.is_a?(Integral)
+    case rhs
+    when Integer, Float
       return numerator <=> rhs if denominator == 1
       rhs = Rational(rhs)
     end
-
     case rhs
     when Rational
       (numerator * rhs.denominator - denominator * rhs.numerator) <=> 0
@@ -65,14 +65,13 @@ class Rational < Numeric
 
   def ==(rhs)
     return true if self.equal?(rhs)
-    if rhs.is_a?(Integral) && denominator == 1
-      return numerator == rhs
-    end
-    if rhs.is_a?(Rational)
-      numerator * rhs.denominator == denominator * rhs.numerator
-    else
-      rhs == self
+    case rhs
+    when Integer, Float
+      return numerator == rhs if denominator == 1
+    when Rational
+      return numerator * rhs.denominator == denominator * rhs.numerator
     end
+    rhs == self
   end
 end
 
diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c
index fcaba3df5..5b1bec9e2 100644
--- a/mrbgems/mruby-rational/src/rational.c
+++ b/mrbgems/mruby-rational/src/rational.c
@@ -102,11 +102,11 @@ rational_s_new(mrb_state *mrb, mrb_value self)
   mrb_value numv, denomv;
 
   mrb_get_args(mrb, "oo", &numv, &denomv);
-  if (mrb_fixnum_p(numv)) {
-    numerator = mrb_fixnum(numv);
+  if (mrb_integer_p(numv)) {
+    numerator = mrb_integer(numv);
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denominator = mrb_integer(denomv);
     }
     else {
       mrb_float denomf = mrb_to_flo(mrb, denomv);
@@ -118,8 +118,8 @@ rational_s_new(mrb_state *mrb, mrb_value self)
   else {
     mrb_float numf = mrb_to_flo(mrb, numv);
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denominator = mrb_integer(denomv);
     }
     else {
       mrb_float denomf = mrb_to_flo(mrb, denomv);
@@ -176,7 +176,7 @@ rational_negative_p(mrb_state *mrb, mrb_value self)
 static mrb_value
 fix_to_r(mrb_state *mrb, mrb_value self)
 {
-  return rational_new(mrb, mrb_fixnum(self), 1);
+  return rational_new(mrb, mrb_integer(self), 1);
 }
 
 void mrb_mruby_rational_gem_init(mrb_state *mrb)
diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c
index 6542c1603..d94573c96 100644
--- a/mrbgems/mruby-socket/src/socket.c
+++ b/mrbgems/mruby-socket/src/socket.c
@@ -140,7 +140,7 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
 
   if (mrb_string_p(service)) {
     servname = RSTRING_CSTR(mrb, service);
-  } else if (mrb_fixnum_p(service)) {
+  } else if (mrb_integer_p(service)) {
     servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10));
   } else if (mrb_nil_p(service)) {
     servname = NULL;
@@ -151,16 +151,16 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
   memset(&hints, 0, sizeof(hints));
   hints.ai_flags = (int)flags;
 
-  if (mrb_fixnum_p(family)) {
-    hints.ai_family = (int)mrb_fixnum(family);
+  if (mrb_integer_p(family)) {
+    hints.ai_family = (int)mrb_integer(family);
   }
 
-  if (mrb_fixnum_p(socktype)) {
-    hints.ai_socktype = (int)mrb_fixnum(socktype);
+  if (mrb_integer_p(socktype)) {
+    hints.ai_socktype = (int)mrb_integer(socktype);
   }
 
-  if (mrb_fixnum_p(protocol)) {
-    hints.ai_protocol = (int)mrb_fixnum(protocol);
+  if (mrb_integer_p(protocol)) {
+    hints.ai_protocol = (int)mrb_integer(protocol);
   }
 
   lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai));
@@ -269,7 +269,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
 static int
 socket_fd(mrb_state *mrb, mrb_value sock)
 {
-  return (int)mrb_fixnum(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
+  return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
 }
 
 static int
@@ -449,21 +449,21 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
 
   argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval);
   if (argc == 3) {
-    if (!mrb_fixnum_p(so)) {
+    if (!mrb_integer_p(so)) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer");
     }
-    level = mrb_fixnum(so);
+    level = mrb_integer(so);
     if (mrb_string_p(optval)) {
       /* that's good */
     } else if (mrb_true_p(optval) || mrb_false_p(optval)) {
       mrb_int i = mrb_test(optval) ? 1 : 0;
       optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
-    } else if (mrb_fixnum_p(optval)) {
+    } else if (mrb_integer_p(optval)) {
       if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) {
-        char uc = (char)mrb_fixnum(optval);
+        char uc = (char)mrb_integer(optval);
         optval = mrb_str_new(mrb, &uc, sizeof(uc));
       } else {
-        mrb_int i = mrb_fixnum(optval);
+        mrb_int i = mrb_integer(optval);
         optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
       }
     } else {
@@ -472,8 +472,8 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
   } else if (argc == 1) {
     if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0)
       mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option");
-    level = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(level), 0));
-    optname = mrb_fixnum(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0));
+    level = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(level), 0));
+    optname = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0));
     optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0);
   } else {
     mrb_argnum_error(mrb, argc, 3, 3);
diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c
index 4df3e3a17..9ac8a512d 100644
--- a/mrbgems/mruby-sprintf/src/sprintf.c
+++ b/mrbgems/mruby-sprintf/src/sprintf.c
@@ -74,7 +74,7 @@ static mrb_value
 mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
 {
   char buf[66], *b = buf + sizeof buf;
-  mrb_int num = mrb_fixnum(x);
+  mrb_int num = mrb_integer(x);
   uint64_t val = (uint64_t)num;
   char d;
 
@@ -764,8 +764,8 @@ retry:
             mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
           }
         }
-        else if (mrb_fixnum_p(val)) {
-          mrb_int n = mrb_fixnum(val);
+        else if (mrb_integer_p(val)) {
+          mrb_int n = mrb_integer(val);
 #ifndef MRB_UTF8_STRING
           char buf[1];
 
@@ -882,14 +882,14 @@ retry:
 #ifndef MRB_NO_FLOAT
           case MRB_TT_FLOAT:
             val = mrb_flo_to_fixnum(mrb, val);
-            if (mrb_fixnum_p(val)) goto bin_retry;
+            if (mrb_integer_p(val)) goto bin_retry;
             break;
 #endif
           case MRB_TT_STRING:
             val = mrb_str_to_inum(mrb, val, 0, TRUE);
             goto bin_retry;
           case MRB_TT_INTEGER:
-            v = mrb_fixnum(val);
+            v = mrb_integer(val);
             break;
           default:
             val = mrb_Integer(mrb, val);
diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c
index 71fb5bb65..4b8f99597 100644
--- a/mrbgems/mruby-string-ext/src/string.c
+++ b/mrbgems/mruby-string-ext/src/string.c
@@ -166,7 +166,7 @@ mrb_str_concat_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value str = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(str) || mrb_float_p(str))
+  if (mrb_integer_p(str) || mrb_float_p(str))
 #ifdef MRB_UTF8_STRING
     str = int_chr_utf8(mrb, str);
 #else
@@ -1231,7 +1231,7 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb)
 
   mrb_define_method(mrb, s, "__lines",         mrb_str_lines,           MRB_ARGS_NONE());
 
-  mrb_define_method(mrb, mrb_module_get(mrb, "Integral"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, mrb_class_get(mrb, "Integer"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
 }
 
 void
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index 1189381cb..7c6f50090 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -113,7 +113,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_struct_ref(mrb_state *mrb, mrb_value obj)
 {
-  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
   mrb_value *ptr = RSTRUCT_PTR(obj);
 
   if (!ptr) return mrb_nil_value();
@@ -152,7 +152,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
 static mrb_value
 mrb_struct_set_m(mrb_state *mrb, mrb_value obj)
 {
-  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
   mrb_value *ptr;
   mrb_value val = mrb_get_arg1(mrb);
 
diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c
index 4b82a9abc..b22888ec5 100644
--- a/mrbgems/mruby-test/driver.c
+++ b/mrbgems/mruby-test/driver.c
@@ -252,9 +252,9 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
 #define TEST_COUNT_PASS(name)                                           \
   do {                                                                  \
     res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name));  \
-    if (mrb_fixnum_p(res_src)) {                                        \
+    if (mrb_integer_p(res_src)) {                                       \
       mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \
-      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_fixnum(res_dst) + mrb_fixnum(res_src))); \
+      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_integer(res_dst) + mrb_integer(res_src))); \
     }                                                                   \
   } while (FALSE)                                                       \
 
diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c
index 8a4f1d233..2af86b14e 100644
--- a/mrbgems/mruby-time/src/time.c
+++ b/mrbgems/mruby-time/src/time.c
@@ -218,11 +218,15 @@ typedef mrb_int mrb_sec;
                     (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
 )
 
+/* return true if time_t is fit in mrb_int */
 static mrb_bool
 fixable_time_t_p(time_t v)
 {
   if (MRB_INT_MIN <= MRB_TIME_MIN && MRB_TIME_MAX <= MRB_INT_MAX) return TRUE;
-  return FIXABLE(v);
+  if (v > (time_t)MRB_INT_MAX) return FALSE;
+  if (MRB_TIME_T_UINT) return TRUE;
+  if (MRB_INT_MIN > (mrb_int)v) return FALSE;
+  return TRUE;
 }
 
 static time_t
@@ -880,11 +884,6 @@ mrb_time_usec(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
 
   tm = time_get_ptr(mrb, self);
-#ifndef MRB_NO_FLOAT
-  if (!fixable_time_t_p(tm->usec)) {
-    return mrb_float_value(mrb, (mrb_float)tm->usec);
-  }
-#endif
   return mrb_fixnum_value((mrb_int)tm->usec);
 }