Reimplement vformat tests; close #4868

Avoid creating `Data` object that refers `mruby` objects.
Also close #4622 ref #4613

mrbgems/mruby-test/vformat.c

@@ -4,197 +4,148 @@
 #include <mruby/data.h>
 #include <mruby/string.h>
 
-#ifdef MRB_WITHOUT_FLOAT
+/* no argument */
-typedef mrb_int mrb_float;
-#define mrb_float(o) mrb_fixnum(o)
-#endif
-
-#define NATIVE_TYPES                                                        \
-  char c;                                                                   \
-  int d;                                                                    \
-  mrb_float f;                                                              \
-  mrb_int i;                                                                \
-/*  size_t l;                                                             */\
-  mrb_sym n;                                                                \
-  char *s;                                                                  \
-  struct RClass *C
-
-#define NATIVE_DEFINE_TYPE_FUNC(t)                                          \
-  static mrb_value                                                          \
-  native_s_##t(mrb_state *mrb, mrb_value klass)                             \
-  {                                                                         \
-    mrb_value obj, type = mrb_fixnum_value(ARG_##t);                        \
-    mrb_get_args(mrb, "o", &obj);                                           \
-    return mrb_funcall(mrb, klass, "new", 2, type, obj);                    \
-  }
-
-#define NATIVE_DEFINE_TYPE_METHOD(t) \
-  mrb_define_class_method(mrb, n, #t, native_s_##t, MRB_ARGS_REQ(1))
-
-typedef enum {
-  ARG_c,
-  ARG_d,
-  ARG_f,
-  ARG_i,
-/*  ARG_l,*/
-  ARG_n,
-  ARG_s,
-  ARG_C,
-  ARG_v,
-} VFArgumentType;
-
-typedef struct {
-  VFArgumentType type;
-  union { NATIVE_TYPES; };
-} VFNative;
-
-typedef struct {
-  VFArgumentType type;
-  union {
-    NATIVE_TYPES;
-    mrb_value v;
-  };
-} VFArgument;
-
-static void
-native_free(mrb_state *mrb, void *data)
-{
-  VFNative *native = (VFNative*)data;
-  if (native->type == ARG_s) mrb_free(mrb, native->s);
-  mrb_free(mrb, native);
-}
-
-static const struct mrb_data_type native_data_type = {
-  "TestVFormat::Native", native_free
-};
-
 static mrb_value
-native_initialize(mrb_state *mrb, mrb_value self)
+vf_s_format_0(mrb_state *mrb, mrb_value klass)
 {
-  VFNative data, *datap;
+  mrb_value fmt_str;
-  mrb_int type;
+  mrb_get_args(mrb, "S", &fmt_str);
-  mrb_value obj;
-
-  mrb_get_args(mrb, "io", &type, &obj);
-  data.type = (VFArgumentType)type;
-  switch (data.type) {
-    case ARG_c: data.c = RSTRING_PTR(obj)[0]; break;
-    case ARG_d: data.d = (int)mrb_fixnum(obj); break;
-    case ARG_f: data.f = mrb_float(obj); break;
-    case ARG_i: data.i = mrb_fixnum(obj); break;
-/*    case ARG_l: data.l = (size_t)mrb_fixnum(obj); break;*/
-    case ARG_n: data.n = mrb_symbol(obj); break;
-    case ARG_s: data.s = (char*)mrb_malloc(mrb, RSTRING_LEN(obj) + 1);
-                memcpy(data.s, RSTRING_PTR(obj), RSTRING_LEN(obj));
-                data.s[RSTRING_LEN(obj)] = '\0'; break;
-    case ARG_C: data.C = mrb_class_ptr(obj); break;
-    default: mrb_raise(mrb, E_ARGUMENT_ERROR, "unknown type");
-  }
-  datap = (VFNative*)mrb_malloc(mrb, sizeof(VFNative));
-  *datap = data;
-  mrb_data_init(self, datap, &native_data_type);
-  return self;
-}
-
-NATIVE_DEFINE_TYPE_FUNC(c)
-NATIVE_DEFINE_TYPE_FUNC(d)
-NATIVE_DEFINE_TYPE_FUNC(f)
-NATIVE_DEFINE_TYPE_FUNC(i)
-/*NATIVE_DEFINE_TYPE_FUNC(l)*/
-NATIVE_DEFINE_TYPE_FUNC(n)
-NATIVE_DEFINE_TYPE_FUNC(s)
-NATIVE_DEFINE_TYPE_FUNC(C)
-
-static VFArgument*
-arg_from_obj(mrb_state *mrb, mrb_value obj, struct RClass *native_class,
-             VFArgument *vf_arg)
-{
-  if (mrb_obj_is_instance_of(mrb, obj, native_class)) {
-    const VFNative *native = (VFNative*)DATA_PTR(obj);
-    *(VFNative*)vf_arg = *native;
-  }
-  else {
-    vf_arg->v = obj;
-    vf_arg->type = ARG_v;
-  }
-  return vf_arg;
-}
-
-#define VF_FORMAT_INIT(klass)                                               \
-  struct RClass *vf_native_class =                                          \
-    mrb_class_get_under(mrb, mrb_class_ptr(klass), "Native");               \
-  VFArgument vf_args[2];
-
-#define VF_ARG(args, idx) \
-  arg_from_obj(mrb, args[idx], vf_native_class, &vf_args[idx])
-
-#define VF_FORMAT0(fmt) mrb_format(mrb, fmt);
-#define VF_FORMAT1(fmt, args) \
-  (VF_ARG(args, 0), VF_FORMAT_TYPED(fmt, 1, vf_args, NULL))
-#define VF_FORMAT2(fmt, args) (                                             \
-  VF_ARG(args, 0), VF_ARG(args, 1),                                         \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, c) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, d) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, f) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, i) :                        \
-/*  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, l) :                    */\
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, n) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, s) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, C) :                        \
-  VF_FORMAT2_COND_EXPR(fmt, vf_args, vf_args+1, v) :                        \
-  mrb_nil_value()  /* not reached */                                        \
-)
-#define VF_FORMAT2_COND_EXPR(fmt, a1, a2, t) \
-  a1->type == ARG_##t ? VF_FORMAT_TYPED(fmt, 2, a2, (a1)->t)
-#define VF_FORMAT_TYPED(fmt, n_arg, type_a, v1)                             \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, c) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, d) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, f) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, i) :                    \
-/*  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, l) :                */\
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, n) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, s) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, C) :                    \
-  VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, v) :                    \
-  mrb_nil_value()  /* not reached */
-#define VF_FORMAT_TYPED_COND_EXPR(fmt, n_arg, type_a, v1, t)                \
-  (type_a)->type == ARG_##t ? n_arg == 1 ?                                  \
-    mrb_format(mrb, fmt, (type_a)->t) : mrb_format(mrb, fmt, v1, (type_a)->t)
-
-static mrb_value
-vf_s_format(mrb_state *mrb, mrb_value klass)
-{
-  mrb_value fmt_str, args[2];
-  mrb_int argc = mrb_get_args(mrb, "S|oo", &fmt_str, args, args+1);
   const char *fmt = RSTRING_CSTR(mrb, fmt_str);
 
-  VF_FORMAT_INIT(klass);
+  return mrb_format(mrb, fmt);
+}
 
-  switch (argc) {
+/* c char */
-    case 1: return VF_FORMAT0(fmt);
+static mrb_value
-    case 2: return VF_FORMAT1(fmt, args);
+vf_s_format_c(mrb_state *mrb, mrb_value klass)
-    case 3: return VF_FORMAT2(fmt, args);
+{
-    default: return mrb_nil_value();  /* not reached */
+  mrb_value fmt_str, arg_str;
-  }
+  mrb_get_args(mrb, "SS", &fmt_str, &arg_str);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const char c = RSTRING_CSTR(mrb, arg_str)[0];
+
+  return mrb_format(mrb, fmt, c);
+}
+
+/* d int */
+static mrb_value
+vf_s_format_d(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_int;
+  mrb_get_args(mrb, "Si", &fmt_str, &arg_int);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const int d = mrb_fixnum(arg_int);
+
+  return mrb_format(mrb, fmt, d);
+}
+
+#ifndef MRB_WITHOUT_FLOAT
+/* f float */
+static mrb_value
+vf_s_format_f(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_flt;
+  mrb_get_args(mrb, "Sf", &fmt_str, &arg_flt);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const mrb_float f = mrb_float(arg_flt);
+
+  return mrb_format(mrb, fmt, f);
+}
+#endif
+
+/* i fixnum */
+static mrb_value
+vf_s_format_i(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_int;
+  mrb_get_args(mrb, "Si", &fmt_str, &arg_int);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const mrb_int i = mrb_fixnum(arg_int);
+
+  return mrb_format(mrb, fmt, i);
+}
+
+/* l char*, size_t */
+static mrb_value
+vf_s_format_l(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str, arg_int;
+  mrb_get_args(mrb, "SSi", &fmt_str, &arg_str, &arg_int);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const char *s = RSTRING_PTR(arg_str);
+  size_t len = (size_t)mrb_fixnum(arg_int);
+  if (len > (size_t)RSTRING_LEN(arg_str)) len = (size_t)RSTRING_LEN(arg_str);
+
+  return mrb_format(mrb, fmt, s, len);
+}
+
+/* n symbol */
+static mrb_value
+vf_s_format_n(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_sym;
+  mrb_get_args(mrb, "Sn", &fmt_str, &arg_sym);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const mrb_sym n = mrb_symbol(arg_sym);
+
+  return mrb_format(mrb, fmt, n);
+}
+
+/* s char* */
+static mrb_value
+vf_s_format_s(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_str;
+  mrb_get_args(mrb, "SS", &fmt_str, &arg_str);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const char *s = RSTRING_CSTR(mrb, arg_str);
+
+  return mrb_format(mrb, fmt, s);
+}
+
+/* C RClass */
+static mrb_value
+vf_s_format_C(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_cls;
+  mrb_get_args(mrb, "SC", &fmt_str, &arg_cls);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+  const struct RClass *c = mrb_class_ptr(arg_cls);
+
+  return mrb_format(mrb, fmt, c);
+}
+
+/* v value */
+static mrb_value
+vf_s_format_v(mrb_state *mrb, mrb_value klass)
+{
+  mrb_value fmt_str, arg_v;
+  mrb_get_args(mrb, "So", &fmt_str, &arg_v);
+  const char *fmt = RSTRING_CSTR(mrb, fmt_str);
+
+  return mrb_format(mrb, fmt, arg_v);
 }
 
 void
 mrb_init_test_vformat(mrb_state *mrb)
 {
-  struct RClass *vf, *n;
+  struct RClass *vf;
 
   vf = mrb_define_module(mrb, "TestVFormat");
-  mrb_define_class_method(mrb, vf, "format", vf_s_format, MRB_ARGS_ARG(1,2));
+  mrb_define_class_method(mrb, vf, "z", vf_s_format_0, MRB_ARGS_REQ(1));
 
-  n = mrb_define_class_under(mrb, vf, "Native", mrb->object_class);
+#define VF_DEFINE_FORMAT_METHOD(t) VF_DEFINE_FORMAT_METHOD_n(t,2)
-  MRB_SET_INSTANCE_TT(n, MRB_TT_DATA);
+#define VF_DEFINE_FORMAT_METHOD_n(t,n) mrb_define_class_method(mrb, vf, #t, vf_s_format_##t, MRB_ARGS_REQ(n));
-  NATIVE_DEFINE_TYPE_METHOD(c);
+  
-  NATIVE_DEFINE_TYPE_METHOD(d);
+  VF_DEFINE_FORMAT_METHOD(c);
-  NATIVE_DEFINE_TYPE_METHOD(f);
+  VF_DEFINE_FORMAT_METHOD(d);
-  NATIVE_DEFINE_TYPE_METHOD(i);
+#ifndef MRB_WITHOUT_FLOAT
-/*  NATIVE_DEFINE_TYPE_METHOD(l);*/
+  VF_DEFINE_FORMAT_METHOD(f);
-  NATIVE_DEFINE_TYPE_METHOD(n);
+#endif
-  NATIVE_DEFINE_TYPE_METHOD(s);
+  VF_DEFINE_FORMAT_METHOD(i);
-  NATIVE_DEFINE_TYPE_METHOD(C);
+  VF_DEFINE_FORMAT_METHOD_n(l,3);
-  mrb_define_method(mrb, n, "initialize", native_initialize, MRB_ARGS_REQ(2));
+  VF_DEFINE_FORMAT_METHOD(n);
+  VF_DEFINE_FORMAT_METHOD(s);
+  VF_DEFINE_FORMAT_METHOD(C);
+  VF_DEFINE_FORMAT_METHOD(v);
 }

test/t/vformat.rb

@@ -1,25 +1,4 @@
-def assert_format(exp, args)
+# coding: utf-8-emacs
-  assert_equal(exp, TestVFormat.format(*args))
-end
-
-def assert_format_pattern(exp_pattern, args)
-  assert_match(exp_pattern, TestVFormat.format(*args))
-end
-
-# Pass if ArgumentError is raised or return value is +exp+.
-def assert_implementation_dependent(exp, args)
-  begin
-    ret = TestVFormat.format(*args)
-  rescue ArgumentError
-    return pass
-  end
-  if ret == exp
-    pass
-  else
-    flunk "", "Expected ArgumentError is raised or #{ret.inspect} to be #{exp}."
-  end
-end
-
 def sclass(v)
   class << v
     self
@@ -27,66 +6,53 @@ def sclass(v)
 end
 
 assert('mrb_vformat') do
-  n = TestVFormat::Native
+  vf = TestVFormat
-  assert_format '', ['']
+  assert_equal '', vf.z('')
-  assert_format 'No specifier!', ['No specifier!']
+  assert_equal 'No specifier!', vf.z('No specifier!')
-  assert_format '`c`: C', ['`c`: %c', n.c(?C)]
+  assert_equal '`c`: C', vf.c('`c`: %c', ?C)
-  assert_format '`d`: 123', ['`d`: %d', n.d(123)]
+  assert_equal '`d`: 123', vf.d('`d`: %d', 123)
-  assert_format '`d`: -79', ['`d`: %d', n.d(-79)]
+  assert_equal '`d`: -79', vf.d('`d`: %d', -79)
-  assert_format '`i`: 514', ['`i`: %i', n.i(514)]
+  assert_equal '`i`: 514', vf.i('`i`: %i', 514)
-  assert_format '`i`: -83', ['`i`: %i', n.i(-83)]
+  assert_equal '`i`: -83', vf.i('`i`: %i', -83)
-  assert_format '`t`: NilClass', ['`t`: %t', nil]
+  assert_equal '`t`: NilClass', vf.v('`t`: %t', nil)
-  assert_format '`t`: FalseClass', ['`t`: %t', false]
+  assert_equal '`t`: FalseClass', vf.v('`t`: %t', false)
-  assert_format '`t`: TrueClass', ['`t`: %t', true]
+  assert_equal '`t`: TrueClass', vf.v('`t`: %t', true)
-  assert_format '`t`: Fixnum', ['`t`: %t', 0]
+  assert_equal '`t`: Fixnum', vf.v('`t`: %t', 0)
-  assert_format '`t`: Hash', ['`t`: %t', k: "value"]
+  assert_equal '`t`: Hash', vf.v('`t`: %t', {k: "value"})
-  assert_format_pattern '#<Class:#<Class:#<Hash:0x*>>>', ['%t', sclass({})]
+  assert_match '#<Class:#<Class:#<Hash:0x*>>>', vf.v('%t', sclass({}))
-#  assert_format 'string and length', ['string %l length', n.s('andante'), n.l(3)]
+  assert_equal 'string and length', vf.l('string %l length', 'andante', 3)
-  assert_format '`n`: sym', ['`n`: %n', n.n(:sym)]
+  assert_equal '`n`: sym', vf.n('`n`: %n', :sym)
-  assert_format '%C文字列%', ['%s', n.s('%C文字列%')]
+  assert_equal '%C文字列����%', vf.s('%s', '%C文字列����%')
-  assert_format '`C`: Kernel module', ['`C`: %C module', n.C(Kernel)]
+  assert_equal '`C`: Kernel module', vf.C('`C`: %C module', Kernel)
-  assert_format '`C`: NilClass', ['`C`: %C', n.C(nil.class)]
+  assert_equal '`C`: NilClass', vf.C('`C`: %C', nil.class)
-  assert_format_pattern '#<Class:#<String:0x*>>', ['%C', n.C(sclass(""))]
+  assert_match '#<Class:#<String:0x*>>', vf.C('%C', sclass(""))
-  assert_format '`T`: NilClass', ['`T`: %T', nil]
+  assert_equal '`T`: NilClass', vf.v('`T`: %T', nil)
-  assert_format '`T`: FalseClass', ['`T`: %T', false]
+  assert_equal '`T`: FalseClass', vf.v('`T`: %T', false)
-  assert_format '`T`: TrueClass', ['`T`: %T', true]
+  assert_equal '`T`: TrueClass', vf.v('`T`: %T', true)
-  assert_format '`T`: Fixnum', ['`T`: %T', 0]
+  assert_equal '`T`: Fixnum', vf.v('`T`: %T', 0)
-  assert_format '`T`: Hash', ['`T`: %T', k: "value"]
+  assert_equal '`T`: Hash', vf.v('`T`: %T', {k: "value"})
-  assert_format_pattern 'Class', ['%T', sclass({})]
+  assert_match 'Class', vf.v('%T', sclass({}))
-  assert_format '`Y`: nil', ['`Y`: %Y', nil]
+  assert_equal '`Y`: nil', vf.v('`Y`: %Y', nil)
-  assert_format '`Y`: false', ['`Y`: %Y', false]
+  assert_equal '`Y`: false', vf.v('`Y`: %Y', false)
-  assert_format '`Y`: true', ['`Y`: %Y', true]
+  assert_equal '`Y`: true', vf.v('`Y`: %Y', true)
-  assert_format '`Y`: Fixnum', ['`Y`: %Y', 0]
+  assert_equal '`Y`: Fixnum', vf.v('`Y`: %Y', 0)
-  assert_format '`Y`: Hash', ['`Y`: %Y', k: "value"]
+  assert_equal '`Y`: Hash', vf.v('`Y`: %Y', {k: "value"})
-  assert_format 'Class', ['%Y', sclass({})]
+  assert_equal 'Class', vf.v('%Y', sclass({}))
-  assert_format_pattern '#<Class:#<String:0x*>>', ['%v', sclass("")]
+  assert_match '#<Class:#<String:0x*>>', vf.v('%v', sclass(""))
-  assert_format '`v`: 1...3', ['`v`: %v', 1...3]
+  assert_equal '`v`: 1...3', vf.v('`v`: %v', 1...3)
-  assert_format '`S`: {:a=>1, "b"=>"c"}', ['`S`: %S', a: 1, "b" => ?c]
+  assert_equal '`S`: {:a=>1, "b"=>"c"}', vf.v('`S`: %S', {a: 1, "b" => ?c})
-  assert_format 'percent: %', ['percent: %%']
+  assert_equal 'percent: %', vf.z('percent: %%')
-  assert_format '"I": inspect char', ['%!c: inspect char', n.c(?I)]
+  assert_equal '"I": inspect char', vf.c('%!c: inspect char', ?I)
-  assert_format '709: inspect mrb_int', ['%!d: inspect mrb_int', n.i(709)]
+  assert_equal '709: inspect mrb_int', vf.i('%!d: inspect mrb_int', 709)
-#  assert_format '"a\x00b\xff"', ['%!l', n.s("a\000b\xFFc\000d"), n.l(4)]
+  assert_equal '"a\x00b\xff"', vf.l('%!l', "a\000b\xFFc\000d", 4)
-  assert_format ':"&.": inspect symbol', ['%!n: inspect symbol', n.n(:'&.')]
+  assert_equal ':"&.": inspect symbol', vf.n('%!n: inspect symbol', :'&.')
-  assert_format 'inspect "String"', ['inspect %!v', 'String']
+  assert_equal 'inspect "String"', vf.v('inspect %!v', 'String')
-  assert_format 'inspect Array: [1, :x, {}]', ['inspect Array: %!v', [1,:x,{}]]
+  assert_equal 'inspect Array: [1, :x, {}]', vf.v('inspect Array: %!v', [1,:x,{}])
-  assert_format_pattern '`!C`: #<Class:0x*>', ['`!C`: %!C', n.C(Class.new)]
+  assert_match '`!C`: #<Class:0x*>', vf.C('`!C`: %!C', Class.new)
-  assert_format 'to_s -> to_s: ab,cd', ['to_s -> to_s: %n,%v', n.n(:ab), 'cd']
+  assert_equal 'escape: \\%a,b,c,d', vf.v('escape: \\\\\%a,b,\c%v', ',d')
-  assert_format 'to_s -> inspect: x:y', ['to_s -> inspect: %v%!v', 'x', :y]
-  assert_format 'inspect -> to_s: "a"b', ['inspect -> to_s: %!v%n', 'a', n.n(:b)]
-  assert_format 'Y -> to_s: nile', ['Y -> to_s: %Y%v', nil, "e"]
-  assert_format '"abc":Z', ['%!s%!n', n.s('abc'), n.n('Z'.to_sym)]
-  assert_format 'escape: \\%a,b,c,d', ['escape: \\\\\%a,b,\c%v', ',d']
-
-  assert_implementation_dependent 'unknown specifier: %^',
-                                  ['unknown specifier: %^']
-  assert_implementation_dependent 'unknown specifier with modifier: %!^',
-                                  ['unknown specifier with modifier: %!^']
-  assert_implementation_dependent 'termination is \\', ['termination is \\']
-  assert_implementation_dependent 'termination is %', ['termination is %']
-  assert_implementation_dependent 'termination is %!', ['termination is %!']
 
   skip unless Object.const_defined?(:Float)
-  assert_format '`f`: 0.0125', ['`f`: %f', n.f(0.0125)]
+  assert_equal '`f`: 0.0125', vf.f('`f`: %f', 0.0125)
-  assert_format '-Infinity', ['%f', n.f(-Float::INFINITY)]
+  assert_equal '-Infinity', vf.f('%f', -Float::INFINITY)
-  assert_format 'NaN: Not a Number', ['%f: Not a Number', n.f(Float::NAN)]
+  assert_equal 'NaN: Not a Number', vf.f('%f: Not a Number', Float::NAN)
 end