mirror of
https://github.com/mruby/mruby
synced 2026-06-08 16:11:16 +00:00
Merge pull request #2924 from zzak/mruby-test
Extract mrbtest to binary gem
This commit is contained in:
Yukihiro "Matz" Matsumoto
@@ -1,7 +0,0 @@
|
||||
Running Tests
|
||||
=============
|
||||
|
||||
To run the tests, execute the following from the project's root directory.
|
||||
|
||||
$ make test
|
||||
|
||||
-166
@@ -1,166 +0,0 @@
|
||||
/*
|
||||
** mrbtest - Test for Embeddable Ruby
|
||||
**
|
||||
** This program runs Ruby test programs in test/t directory
|
||||
** against the current mruby implementation.
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mruby.h"
|
||||
#include "mruby/proc.h"
|
||||
#include "mruby/data.h"
|
||||
#include "mruby/compile.h"
|
||||
#include "mruby/string.h"
|
||||
#include "mruby/variable.h"
|
||||
#include "mruby/array.h"
|
||||
|
||||
void
|
||||
mrb_init_mrbtest(mrb_state *);
|
||||
|
||||
/* Print a short remark for the user */
|
||||
static void
|
||||
print_hint(void)
|
||||
{
|
||||
printf("mrbtest - Embeddable Ruby Test\n\n");
|
||||
}
|
||||
|
||||
static int
|
||||
check_error(mrb_state *mrb)
|
||||
{
|
||||
/* Error check */
|
||||
/* $ko_test and $kill_test should be 0 */
|
||||
mrb_value ko_test = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$ko_test"));
|
||||
mrb_value kill_test = mrb_gv_get(mrb, mrb_intern_lit(mrb, "$kill_test"));
|
||||
|
||||
return mrb_fixnum_p(ko_test) && mrb_fixnum(ko_test) == 0 && mrb_fixnum_p(kill_test) && mrb_fixnum(kill_test) == 0;
|
||||
}
|
||||
|
||||
static int
|
||||
eval_test(mrb_state *mrb)
|
||||
{
|
||||
/* evaluate the test */
|
||||
mrb_funcall(mrb, mrb_top_self(mrb), "report", 0);
|
||||
/* did an exception occur? */
|
||||
if (mrb->exc) {
|
||||
mrb_print_error(mrb);
|
||||
mrb->exc = 0;
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
else if (!check_error(mrb)) {
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
static void
|
||||
t_printstr(mrb_state *mrb, mrb_value obj)
|
||||
{
|
||||
char *s;
|
||||
int len;
|
||||
|
||||
if (mrb_string_p(obj)) {
|
||||
s = RSTRING_PTR(obj);
|
||||
len = RSTRING_LEN(obj);
|
||||
fwrite(s, len, 1, stdout);
|
||||
}
|
||||
}
|
||||
|
||||
mrb_value
|
||||
mrb_t_printstr(mrb_state *mrb, mrb_value self)
|
||||
{
|
||||
mrb_value argv;
|
||||
|
||||
mrb_get_args(mrb, "o", &argv);
|
||||
t_printstr(mrb, argv);
|
||||
|
||||
return argv;
|
||||
}
|
||||
|
||||
void
|
||||
mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose)
|
||||
{
|
||||
struct RClass *krn, *mrbtest;
|
||||
|
||||
krn = mrb->kernel_module;
|
||||
mrb_define_method(mrb, krn, "__t_printstr__", mrb_t_printstr, MRB_ARGS_REQ(1));
|
||||
|
||||
mrbtest = mrb_define_module(mrb, "Mrbtest");
|
||||
|
||||
mrb_define_const(mrb, mrbtest, "FIXNUM_MAX", mrb_fixnum_value(MRB_INT_MAX));
|
||||
mrb_define_const(mrb, mrbtest, "FIXNUM_MIN", mrb_fixnum_value(MRB_INT_MIN));
|
||||
mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT));
|
||||
|
||||
if (verbose) {
|
||||
mrb_gv_set(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"), mrb_true_value());
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
|
||||
{
|
||||
mrb_value res_src;
|
||||
|
||||
if (mrb_src->exc) {
|
||||
mrb_print_error(mrb_src);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
#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)) { \
|
||||
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))); \
|
||||
} \
|
||||
} while (FALSE) \
|
||||
|
||||
TEST_COUNT_PASS(ok_test);
|
||||
TEST_COUNT_PASS(ko_test);
|
||||
TEST_COUNT_PASS(kill_test);
|
||||
|
||||
#undef TEST_COUNT_PASS
|
||||
|
||||
res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$asserts"));
|
||||
|
||||
if (mrb_array_p(res_src)) {
|
||||
mrb_int i;
|
||||
mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$asserts"));
|
||||
for (i = 0; i < RARRAY_LEN(res_src); ++i) {
|
||||
mrb_value val_src = RARRAY_PTR(res_src)[i];
|
||||
mrb_ary_push(mrb_dst, res_dst, mrb_str_new(mrb_dst, RSTRING_PTR(val_src), RSTRING_LEN(val_src)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
mrb_state *mrb;
|
||||
int ret;
|
||||
mrb_bool verbose = FALSE;
|
||||
|
||||
print_hint();
|
||||
|
||||
/* new interpreter instance */
|
||||
mrb = mrb_open();
|
||||
if (mrb == NULL) {
|
||||
fprintf(stderr, "Invalid mrb_state, exiting test driver");
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'v') {
|
||||
printf("verbose mode: enable\n\n");
|
||||
verbose = TRUE;
|
||||
}
|
||||
|
||||
mrb_init_test_driver(mrb, verbose);
|
||||
mrb_init_mrbtest(mrb);
|
||||
ret = eval_test(mrb);
|
||||
mrb_close(mrb);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
#include <stdlib.h>
|
||||
#include "mruby.h"
|
||||
#include "mruby/irep.h"
|
||||
#include "mruby/variable.h"
|
||||
|
||||
extern const uint8_t mrbtest_assert_irep[];
|
||||
extern const uint8_t mrbtest_irep[];
|
||||
|
||||
void mrbgemtest_init(mrb_state* mrb);
|
||||
void mrb_init_test_driver(mrb_state* mrb, mrb_bool verbose);
|
||||
void mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src);
|
||||
|
||||
void
|
||||
mrb_init_mrbtest(mrb_state *mrb)
|
||||
{
|
||||
mrb_state *core_test;
|
||||
|
||||
mrb_load_irep(mrb, mrbtest_assert_irep);
|
||||
|
||||
core_test = mrb_open_core(mrb_default_allocf, NULL);
|
||||
if (core_test == NULL) {
|
||||
fprintf(stderr, "Invalid mrb_state, exiting %s", __FUNCTION__);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
mrb_init_test_driver(core_test, mrb_test(mrb_gv_get(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"))));
|
||||
mrb_load_irep(core_test, mrbtest_assert_irep);
|
||||
mrb_load_irep(core_test, mrbtest_irep);
|
||||
mrb_t_pass_result(mrb, core_test);
|
||||
|
||||
#ifndef DISABLE_GEMS
|
||||
mrbgemtest_init(mrb);
|
||||
#endif
|
||||
|
||||
if (mrb->exc) {
|
||||
mrb_print_error(mrb);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
mrb_close(core_test);
|
||||
}
|
||||
|
||||
@@ -1,69 +0,0 @@
|
||||
MRuby.each_target do
|
||||
current_dir = File.dirname(__FILE__).relative_path_from(Dir.pwd)
|
||||
relative_from_root = File.dirname(__FILE__).relative_path_from(MRUBY_ROOT)
|
||||
current_build_dir = "#{build_dir}/#{relative_from_root}"
|
||||
|
||||
exec = exefile("#{current_build_dir}/mrbtest")
|
||||
clib = "#{current_build_dir}/mrbtest.c"
|
||||
mlib = clib.ext(exts.object)
|
||||
mrbs = Dir.glob("#{current_dir}/t/*.rb")
|
||||
init = "#{current_dir}/init_mrbtest.c"
|
||||
ass_c = "#{current_build_dir}/assert.c"
|
||||
ass_lib = ass_c.ext(exts.object)
|
||||
|
||||
mrbtest_lib = libfile("#{current_build_dir}/mrbtest")
|
||||
mrbtest_objs = [mlib, ass_lib]
|
||||
gems.each do |v|
|
||||
mrbtest_objs.concat v.test_objs
|
||||
end
|
||||
file mrbtest_lib => mrbtest_objs do |t|
|
||||
archiver.run t.name, t.prerequisites
|
||||
end
|
||||
|
||||
unless build_mrbtest_lib_only?
|
||||
driver_obj = objfile("#{current_build_dir}/driver")
|
||||
file exec => [driver_obj, mrbtest_lib, libfile("#{build_dir}/lib/libmruby")] do |t|
|
||||
gem_flags = gems.map { |g| g.linker.flags }
|
||||
gem_flags_before_libraries = gems.map { |g| g.linker.flags_before_libraries }
|
||||
gem_flags_after_libraries = gems.map { |g| g.linker.flags_after_libraries }
|
||||
gem_libraries = gems.map { |g| g.linker.libraries }
|
||||
gem_library_paths = gems.map { |g| g.linker.library_paths }
|
||||
linker.run t.name, t.prerequisites, gem_libraries, gem_library_paths, gem_flags, gem_flags_before_libraries
|
||||
end
|
||||
end
|
||||
|
||||
file ass_lib => ass_c
|
||||
file ass_c => ["#{current_dir}/assert.rb", __FILE__] do |t|
|
||||
FileUtils.mkdir_p File.dirname t.name
|
||||
open(t.name, 'w') do |f|
|
||||
mrbc.run f, [t.prerequisites.first], 'mrbtest_assert_irep'
|
||||
end
|
||||
end
|
||||
|
||||
file mlib => clib
|
||||
file clib => [mrbcfile, init, __FILE__] + mrbs do |t|
|
||||
_pp "GEN", "*.rb", "#{clib.relative_path}"
|
||||
FileUtils.mkdir_p File.dirname(clib)
|
||||
open(clib, 'w') do |f|
|
||||
f.puts %Q[/*]
|
||||
f.puts %Q[ * This file contains a list of all]
|
||||
f.puts %Q[ * test functions.]
|
||||
f.puts %Q[ *]
|
||||
f.puts %Q[ * IMPORTANT:]
|
||||
f.puts %Q[ * This file was generated!]
|
||||
f.puts %Q[ * All manual changes will get lost.]
|
||||
f.puts %Q[ */]
|
||||
f.puts %Q[]
|
||||
f.puts IO.read(init)
|
||||
mrbc.run f, mrbs, 'mrbtest_irep'
|
||||
gems.each do |g|
|
||||
f.puts %Q[void GENERATED_TMP_mrb_#{g.funcname}_gem_test(mrb_state *mrb);]
|
||||
end
|
||||
f.puts %Q[void mrbgemtest_init(mrb_state* mrb) {]
|
||||
gems.each do |g|
|
||||
f.puts %Q[ GENERATED_TMP_mrb_#{g.funcname}_gem_test(mrb);]
|
||||
end
|
||||
f.puts %Q[}]
|
||||
end
|
||||
end
|
||||
end
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
assert('__FILE__') do
|
||||
file = __FILE__
|
||||
assert_true 'test/t/syntax.rb' == file || 'test\t\syntax.rb' == file
|
||||
file = __FILE__.split('test/')[1]
|
||||
assert_true 't/syntax.rb' == file || 't\syntax.rb' == file
|
||||
end
|
||||
|
||||
assert('__LINE__') do
|
||||
|
||||
Reference in New Issue
Block a user