free 0.1.0-i386-mingw32

data/README.md

@@ -0,0 +1,79 @@
+nfree
+=====
+
+(C) John Mair (banisterfiend) 2010
+
+_force immediate garbage collection of Ruby objects_
+
+free provides the `Object#free` method enabling a user to garbage
+collect an object on demand and free all its internal structures.
+
+* Install the [gem](https://rubygems.org/gems/free)
+* Read the [documentation](http://rdoc.info/github/github/banister/free/master/file/README.markdown)
+* See the [source code](http://github.com/banister/free)
+
+Example: 
+--------
+
+Let's free a String:
+
+    hello = "hello world"
+    id = hello.object_id
+    hello.free
+
+    # Note we go through the id as accessing the freed object directly
+    # may cause a segfault
+    ObjectSpace._id2ref(id) #=> RangeError: _id2ref': 0x1c1a63c is recycled object 
+
+
+Features and limitations
+-------------------------
+
+### Features
+
+* Can free any object (except immediate values, that do not need
+  freeing)
+* Works in both Ruby 1.8 and 1.9, MRI and YARV only.
+
+### Limitations
+
+* Beta software, beware.
+* Can be dangerous - `free` will force garbage collection on an object
+  even if references to it still exist. Trying to access an already freed object may result in unexpected behaviour or segfaults.
+  
+Contact
+-------
+
+Problems or questions contact me at [github](http://github.com/banister)
+
+Special Thanks
+--------------
+
+[Coderrr](http://coderrr.wordpress.com) for the idea
+
+
+License
+-------
+
+(The MIT License) 
+
+Copyright (c) 2011 (John Mair)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,114 @@
+dlext = Config::CONFIG['DLEXT']
+direc = File.dirname(__FILE__)
+
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+PROJECT_NAME = "free"
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require "#{direc}/lib/#{PROJECT_NAME}/version"
+
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o")
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/*.log", "ext/**/*.o",
+              "ext/**/*~", "ext/**/*#*", "ext/**/*.obj", "**/*#*", "**/*#*.*",
+              "ext/**/*.def", "ext/**/*.pdb", "**/*_flymake*.*", "**/*_flymake")
+
+Bones do
+  name  'free'
+  authors  'John Mair (banisterfiend)'
+  email    'jrmair@gmail.com'
+  url      'http://banisterfiend.wordpress.com'
+  ignore_file '.gitignore'
+end        
+
+def apply_spec_defaults(s)
+  s.name = PROJECT_NAME
+  s.summary = "Force immediate garbage collection of an object."
+  s.version = Free::VERSION
+  s.date = Time.now.strftime '%Y-%m-%d'
+  s.author = "John Mair (banisterfiend)"
+  s.email = 'jrmair@gmail.com'
+  s.description = s.summary
+  s.require_path = 'lib'
+  s.homepage = "http://banisterfiend.wordpress.com"
+  s.has_rdoc = 'yard'
+  s.files = Dir["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c", "lib/**/*.rb",
+                     "test/*.rb", "HISTORY", "README.md", "Rakefile"]
+end
+
+desc "run tests"
+task :test do
+  sh "bacon -k #{direc}/test/test.rb"
+end
+
+[:mingw32, :mswin32].each do |v|
+  namespace v do
+    spec = Gem::Specification.new do |s|
+      apply_spec_defaults(s)        
+      s.platform = "i386-#{v}"
+      s.files += FileList["lib/**/*.#{dlext}"].to_a
+    end
+
+    Rake::GemPackageTask.new(spec) do |pkg|
+      pkg.need_zip = false
+      pkg.need_tar = false
+    end
+  end
+end
+
+namespace :ruby do
+  spec = Gem::Specification.new do |s|
+    apply_spec_defaults(s)        
+    s.platform = Gem::Platform::RUBY
+    s.extensions = ["ext/#{PROJECT_NAME}/extconf.rb"]
+  end
+  
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = false
+    pkg.need_tar = false
+  end
+end
+
+directories = ["#{direc}/lib/1.8", "#{direc}/lib/1.9"]
+directories.each { |d| directory d }
+
+desc "build the 1.8 and 1.9 binaries from source and copy to lib/"
+task :compile => directories do
+  build_for = proc do |pik_ver, ver|
+    sh %{ \
+          c:\\devkit\\devkitvars.bat && \
+          pik #{pik_ver} && \
+          ruby extconf.rb && \
+          make clean && \
+          make && \
+          cp *.so #{direc}/lib/#{ver} \
+        }
+  end
+  
+  chdir("#{direc}/ext/#{PROJECT_NAME}") do
+    build_for.call("187", "1.8")
+    build_for.call("192", "1.9")
+  end
+end
+
+desc "build all platform gems at once"
+task :gems => [:clean, :rmgems, "mingw32:gem", "mswin32:gem", "ruby:gem"]
+
+desc "remove all platform gems"
+task :rmgems => ["ruby:clobber_package"]
+
+desc "build and push latest gems"
+task :pushgems => :gems do
+  chdir("#{direc}/pkg") do
+    Dir["*.gem"].each do |gemfile|
+      sh "gem push #{gemfile}"
+    end
+  end
+end
+              
+

data/ext/free/compat.h

@@ -0,0 +1,57 @@
+/* contains basic macros to facilitate ruby 1.8 and ruby 1.9 compatibility */
+
+#ifndef GUARD_COMPAT_H
+#define GUARD_COMPAT_H
+
+#include <ruby.h>
+
+/* test for 1.9 */
+#if !defined(RUBY_19) && defined(ROBJECT_EMBED_LEN_MAX)
+# define RUBY_19
+#endif
+
+/* macros for backwards compatibility with 1.8 */
+#ifndef RUBY_19
+# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+# define RCLASS_SUPER(c) (RCLASS(c)->super)
+# define RCLASS_IV_TBL(c) (RCLASS(c)->iv_tbl)
+# define OBJ_UNTRUSTED OBJ_TAINTED
+# include "st.h"
+#endif
+
+#ifdef RUBY_19
+inline static VALUE
+class_alloc(VALUE flags, VALUE klass)
+{
+  rb_classext_t *ext = ALLOC(rb_classext_t);
+  NEWOBJ(obj, struct RClass);
+  OBJSETUP(obj, klass, flags);
+  obj->ptr = ext;
+  RCLASS_IV_TBL(obj) = 0;
+  RCLASS_M_TBL(obj) = 0;
+  RCLASS_SUPER(obj) = 0;
+  RCLASS_IV_INDEX_TBL(obj) = 0;
+  return (VALUE)obj;
+}
+#endif
+
+inline static VALUE
+create_class(VALUE flags, VALUE klass)
+{
+#ifdef RUBY_19
+  VALUE new_klass = class_alloc(flags, klass);
+#else
+  NEWOBJ(new_klass, struct RClass);
+  OBJSETUP(new_klass, klass, flags);
+#endif
+
+  return (VALUE)new_klass;
+}
+  
+# define FALSE 0
+# define TRUE 1
+
+/* a useful macro. cannot use ordinary CLASS_OF as it does not return an lvalue */
+#define KLASS_OF(c) (RBASIC(c)->klass)
+
+#endif

data/ext/free/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+$CFLAGS += " -std=c99"
+
+create_makefile('free')

data/ext/free/free.c

@@ -0,0 +1,358 @@
+/* (c) 2010 John Mair (banisterfiend), MIT license */
+
+#include <ruby.h>
+#include "compat.h"
+
+#ifdef RUBY_19
+# include <ruby/io.h>
+# include <ruby/re.h>
+# include <vm_core.h>
+#else
+# include "re.h"
+# include "env.h"
+# include "node.h"
+# include "rubysig.h"
+# include "rubyio.h"
+#endif
+
+#include "free.h"
+
+typedef struct RVALUE {
+  union {
+    struct {
+      VALUE flags;		/* always 0 for freed obj */
+      struct RVALUE *next;
+    } free;
+    struct RBasic  basic;
+    struct RObject object;
+    struct RClass  klass;
+    struct RFloat  flonum;
+    struct RString string;
+    struct RArray  array;
+    struct RRegexp regexp;
+    struct RHash   hash;
+    struct RData   data;
+    struct RStruct rstruct;
+    struct RBignum bignum;
+    struct RFile   file;
+    struct RNode   node;
+    struct RMatch  match;
+#ifdef RUBY_19
+    struct RTypedData   typeddata;
+    struct RRational rational;
+    struct RComplex complex;
+#else
+    struct RVarmap varmap;
+    struct SCOPE   scope;
+#endif
+  } as;
+#ifdef GC_DEBUG
+  const char *file;
+  int   line;
+#endif
+} RVALUE;
+
+#define RANY(o) ((RVALUE*)(o))
+
+#ifdef RUBY_19
+static inline void
+make_deferred(RVALUE *p)
+{
+  p->as.basic.flags = (p->as.basic.flags & ~T_MASK) | T_ZOMBIE;
+}
+
+static inline void
+make_io_deferred(RVALUE *p)
+{
+  rb_io_t *fptr = p->as.file.fptr;
+  make_deferred(p);
+  p->as.data.dfree = (void (*)(void*))rb_io_fptr_finalize;
+  p->as.data.data = fptr;
+}
+
+static int
+free_method_entry_i(ID key, rb_method_entry_t *me, st_data_t data)
+{
+  rb_free_method_entry(me);
+  return ST_CONTINUE;
+}
+
+static void
+rb_free_m_table(st_table *tbl)
+{
+  st_foreach(tbl, free_method_entry_i, 0);
+  st_free_table(tbl);
+}
+#else
+
+#define T_DEFERRED 0x3a
+
+static inline void
+make_deferred(RVALUE *p)
+{
+  p->as.basic.flags = (p->as.basic.flags & ~T_MASK) | T_DEFERRED;
+}
+
+#endif
+
+VALUE object_free(VALUE obj)
+{
+#ifdef RUBY_19
+  switch (BUILTIN_TYPE(obj)) {
+  case T_NIL:
+  case T_FIXNUM:
+  case T_TRUE:
+  case T_FALSE:
+    rb_bug("obj_free() called for broken object");
+    break;
+  }
+
+  if (FL_TEST(obj, FL_EXIVAR)) {
+    rb_free_generic_ivar((VALUE)obj);
+    FL_UNSET(obj, FL_EXIVAR);
+  }
+
+  switch (BUILTIN_TYPE(obj)) {
+  case T_OBJECT:
+    if (!(RANY(obj)->as.basic.flags & ROBJECT_EMBED) &&
+        RANY(obj)->as.object.as.heap.ivptr) {
+      xfree(RANY(obj)->as.object.as.heap.ivptr);
+    }
+    break;
+  case T_MODULE:
+  case T_CLASS:
+    rb_clear_cache_by_class((VALUE)obj);
+    rb_free_m_table(RCLASS_M_TBL(obj));
+    if (RCLASS_IV_TBL(obj)) {
+      st_free_table(RCLASS_IV_TBL(obj));
+    }
+    if (RCLASS_IV_INDEX_TBL(obj)) {
+      st_free_table(RCLASS_IV_INDEX_TBL(obj));
+    }
+    xfree(RANY(obj)->as.klass.ptr);
+    break;
+  case T_STRING:
+    rb_str_free(obj);
+    break;
+  case T_ARRAY:
+    rb_ary_free(obj);
+    break;
+  case T_HASH:
+    if (RANY(obj)->as.hash.ntbl) {
+      st_free_table(RANY(obj)->as.hash.ntbl);
+    }
+    break;
+  case T_REGEXP:
+    if (RANY(obj)->as.regexp.ptr) {
+      onig_free(RANY(obj)->as.regexp.ptr);
+    }
+    break;
+  case T_DATA:
+    if (DATA_PTR(obj)) {
+      if (RTYPEDDATA_P(obj)) {
+        RDATA(obj)->dfree = RANY(obj)->as.typeddata.type->dfree;
+      }
+      if ((long)RANY(obj)->as.data.dfree == -1) {
+        xfree(DATA_PTR(obj));
+      }
+      else if (RANY(obj)->as.data.dfree) {
+        make_deferred(RANY(obj));
+        return 1;
+      }
+    }
+    break;
+  case T_MATCH:
+    if (RANY(obj)->as.match.rmatch) {
+      struct rmatch *rm = RANY(obj)->as.match.rmatch;
+      onig_region_free(&rm->regs, 0);
+      if (rm->char_offset)
+        xfree(rm->char_offset);
+      xfree(rm);
+    }
+    break;
+  case T_FILE:
+    if (RANY(obj)->as.file.fptr) {
+      make_io_deferred(RANY(obj));
+      return 1;
+    }
+    break;
+  case T_RATIONAL:
+  case T_COMPLEX:
+    break;
+  case T_ICLASS:
+    /* iClass shares table with the module */
+    xfree(RANY(obj)->as.klass.ptr);
+    break;
+
+  case T_FLOAT:
+    break;
+
+  case T_BIGNUM:
+    if (!(RBASIC(obj)->flags & RBIGNUM_EMBED_FLAG) && RBIGNUM_DIGITS(obj)) {
+      xfree(RBIGNUM_DIGITS(obj));
+    }
+    break;
+  case T_NODE:
+    switch (nd_type(obj)) {
+    case NODE_SCOPE:
+      if (RANY(obj)->as.node.u1.tbl) {
+        xfree(RANY(obj)->as.node.u1.tbl);
+      }
+      break;
+    case NODE_ALLOCA:
+      xfree(RANY(obj)->as.node.u1.node);
+      break;
+    }
+    break;			/* no need to free iv_tbl */
+
+  case T_STRUCT:
+    if ((RBASIC(obj)->flags & RSTRUCT_EMBED_LEN_MASK) == 0 &&
+        RANY(obj)->as.rstruct.as.heap.ptr) {
+      xfree(RANY(obj)->as.rstruct.as.heap.ptr);
+    }
+    break;
+
+  default:
+    rb_bug("gc_sweep(): unknown data type 0x%x(%p)",
+           BUILTIN_TYPE(obj), (void*)obj);
+  }
+
+#else
+  switch (BUILTIN_TYPE(obj)) {
+  case T_NIL:
+  case T_FIXNUM:
+  case T_TRUE:
+  case T_FALSE:
+    rb_bug("obj_free() called for broken object");
+    break;
+  }
+
+  if (FL_TEST(obj, FL_EXIVAR)) {
+    rb_free_generic_ivar((VALUE)obj);
+  }
+
+  switch (BUILTIN_TYPE(obj)) {
+  case T_OBJECT:
+    if (RANY(obj)->as.object.iv_tbl) {
+      st_free_table(RANY(obj)->as.object.iv_tbl);
+    }
+    break;
+  case T_MODULE:
+  case T_CLASS:
+    rb_clear_cache_by_class((VALUE)obj);
+    st_free_table(RANY(obj)->as.klass.m_tbl);
+    if (RANY(obj)->as.object.iv_tbl) {
+      st_free_table(RANY(obj)->as.object.iv_tbl);
+    }
+    break;
+  case T_STRING:
+    if (RANY(obj)->as.string.ptr && !FL_TEST(obj, ELTS_SHARED)) {
+      RUBY_CRITICAL(free(RANY(obj)->as.string.ptr));
+    }
+    break;
+  case T_ARRAY:
+    if (RANY(obj)->as.array.ptr && !FL_TEST(obj, ELTS_SHARED)) {
+      RUBY_CRITICAL(free(RANY(obj)->as.array.ptr));
+    }
+    break;
+  case T_HASH:
+    if (RANY(obj)->as.hash.tbl) {
+      st_free_table(RANY(obj)->as.hash.tbl);
+    }
+    break;
+  case T_REGEXP:
+    if (RANY(obj)->as.regexp.ptr) {
+      re_free_pattern(RANY(obj)->as.regexp.ptr);
+    }
+    if (RANY(obj)->as.regexp.str) {
+      RUBY_CRITICAL(free(RANY(obj)->as.regexp.str));
+    }
+    break;
+  case T_DATA:
+    if (DATA_PTR(obj)) {
+      if ((long)RANY(obj)->as.data.dfree == -1) {
+        RUBY_CRITICAL(free(DATA_PTR(obj)));
+      }
+      else if (RANY(obj)->as.data.dfree) {
+        make_deferred(RANY(obj));
+        return 1;
+      }
+    }
+    break;
+  case T_MATCH:
+    if (RANY(obj)->as.match.regs) {
+      re_free_registers(RANY(obj)->as.match.regs);
+      RUBY_CRITICAL(free(RANY(obj)->as.match.regs));
+    }
+    break;
+  case T_FILE:
+    if (RANY(obj)->as.file.fptr) {
+      struct rb_io_t *fptr = RANY(obj)->as.file.fptr;
+      make_deferred(RANY(obj));
+      RDATA(obj)->dfree = (void (*)(void*))rb_io_fptr_finalize;
+      RDATA(obj)->data = fptr;
+      return 1;
+    }
+    break;
+  case T_ICLASS:
+    /* iClass shares table with the module */
+    break;
+
+  case T_FLOAT:
+  case T_VARMAP:
+  case T_BLKTAG:
+    break;
+
+  case T_BIGNUM:
+    if (RANY(obj)->as.bignum.digits) {
+      RUBY_CRITICAL(free(RANY(obj)->as.bignum.digits));
+    }
+    break;
+  case T_NODE:
+    switch (nd_type(obj)) {
+    case NODE_SCOPE:
+      if (RANY(obj)->as.node.u1.tbl) {
+        RUBY_CRITICAL(free(RANY(obj)->as.node.u1.tbl));
+      }
+      break;
+    case NODE_ALLOCA:
+      RUBY_CRITICAL(free(RANY(obj)->as.node.u1.node));
+      break;
+    }
+    break;			/* no need to free iv_tbl */
+
+  case T_SCOPE:
+    if (RANY(obj)->as.scope.local_vars &&
+        RANY(obj)->as.scope.flags != SCOPE_ALLOCA) {
+      VALUE *vars = RANY(obj)->as.scope.local_vars-1;
+      if (!(RANY(obj)->as.scope.flags & SCOPE_CLONE) && vars[0] == 0)
+        RUBY_CRITICAL(free(RANY(obj)->as.scope.local_tbl));
+      if ((RANY(obj)->as.scope.flags & (SCOPE_MALLOC|SCOPE_CLONE)) == SCOPE_MALLOC)
+        RUBY_CRITICAL(free(vars));
+    }
+    break;
+
+  case T_STRUCT:
+    if (RANY(obj)->as.rstruct.ptr) {
+      RUBY_CRITICAL(free(RANY(obj)->as.rstruct.ptr));
+    }
+    break;
+
+  default:
+    rb_bug("gc_sweep(): unknown data type 0x%lx(0x%lx)",
+           RANY(obj)->as.basic.flags & T_MASK, obj);
+  }
+#endif  
+
+  rb_gc_force_recycle(obj);
+
+  return Qnil;
+}
+
+void
+Init_free()
+{
+  VALUE cFree = rb_define_module("Free");
+  
+  rb_define_method(cFree, "free", object_free, 0);
+}

data/ext/free/free.h

@@ -0,0 +1,6 @@
+#ifndef GUARD_FREE_H
+#define GUARD_FREE_H
+
+VALUE rb_object_free(VALUE obj);
+
+#endif

data/lib/free.rb

@@ -0,0 +1,33 @@
+# free.rb
+# (C) John Mair (banisterfiend); MIT license
+
+direc = File.dirname(__FILE__)
+
+require "#{direc}/free/version"
+
+# @author John Mair (banisterfiend)
+module Free
+
+  # Force garbage collection on an object and free its internal structures.
+  # @return nil
+  # @example
+  #   h = "hello"
+  #   h.free
+  def free() end
+end
+
+begin
+  if RUBY_VERSION =~ /1.9/
+    require "#{direc}/1.9/free"
+  else
+    require "#{direc}/1.8/free"
+  end
+rescue LoadError => e
+  require "rbconfig"
+  dlext = Config::CONFIG['DLEXT']
+  require "#{direc}/free.#{dlext}"
+end
+
+class Object
+  include Free
+end

data/lib/free/version.rb

@@ -0,0 +1,3 @@
+module Free
+  VERSION = "0.1.0"
+end     

data/test/test.rb

@@ -0,0 +1,35 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/free"
+require 'bacon'
+
+puts "Testing free version #{Free::VERSION}..." 
+puts "Ruby version: #{RUBY_VERSION}"
+
+describe Free do
+
+  ["hello", Object.new, Class.new, /hello/, [], {}, 10.5].each do |v|
+    it "should free a #{v.class}" do
+      v
+      # make sure test doesn't pass as a result of normal garbage
+      # collection, so keep a reference to v
+      c = v
+
+      # grab the object id since referring to object directly (through
+      # c) will likely result in segfault, which can't be rescued.
+      id = v.object_id
+
+      ObjectSpace._id2ref(id).should == v
+
+      # free it
+      v.free
+
+      # Two things may happen if it is properly freed:
+      # 1. The _id2ref resolves to another object (the free slot is
+      #   replace by a new object)
+      # 2. Calling _id2ref raises an exception, typically a RangeError
+      (ObjectSpace._id2ref(id)  != v || lambda { ObjectSpace._id2ref(id) } rescue true).should == true
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: free
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: i386-mingw32
+authors: 
+- John Mair (banisterfiend)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-02 00:00:00 +13:00
+default_executable: 
+dependencies: []
+
+description: Force immediate garbage collection of an object.
+email: jrmair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ext/free/extconf.rb
+- ext/free/compat.h
+- ext/free/free.h
+- ext/free/free.c
+- lib/free/version.rb
+- lib/free.rb
+- test/test.rb
+- HISTORY
+- README.md
+- Rakefile
+- lib/1.8/free.so
+- lib/1.9/free.so
+has_rdoc: yard
+homepage: http://banisterfiend.wordpress.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Force immediate garbage collection of an object.
+test_files: []
+