syncache 1.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Czarnecki
+
+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/README.rdoc

@@ -0,0 +1,91 @@
+= SynCache - thread-safe time-limited cache with flexible replacement policy
+
+== Synopsys
+
+  require 'syncache'
+
+  @cache = SynCache::Cache.new
+
+  @cache.fetch_or_add('key:1') do
+    # expensive operation
+  end
+
+  @cache.flush(/^key:/)
+
+
+== Description
+
+SynCache::Cache stores cached objects in a Hash that is protected by an
+advanced two-level locking mechanism. Two-level locking ensures that:
+
+* Multiple threads can add and fetch objects in parallel without
+  stepping on each other's toes.
+
+* While one thread is working on a cache entry, other threads can access
+  the rest of the cache with no waiting on the global lock, no race
+  conditions nor deadlock or livelock situations.
+
+* While one thread is performing a long and resource-intensive
+  operation, other threads that request the same data with #fetch_or_add
+  method will be put on hold, and as soon as the first thread completes
+  the operation, the result will be returned to all threads. Without
+  this feature, a steady stream of requests with less time between them
+  than it takes to complete one request can easily bury a server under
+  an avalanche of threads all wasting resources on the same expensive
+  operation.
+
+When number of cache entries exceeds the size limit, the least recently
+accessed entries are replaced with new data. This replacement strategy
+is controlled by the SynCache::CacheEntry class and can be changed by
+overriding its #replacement_index method.
+
+Cache entries are automatically invalidated when their +ttl+ (time to
+live) is exceeded. Entries can be explicitly invalidated by #flush
+method. The method can use <tt>===</tt> operator to compare cache keys
+against flush base (so that base can be e.g. a Regexp), and invalidates
+all entries when invoked without the +base+ parameter.
+
+The +flush_delay+ initialization option allows to limit cache's flush
+rate. When this option is set, SynCache will make sure that at least
+this many seconds (it can also be a fraction) pass between two flushes.
+When extra flushes are requested, invalidation of flushed entries is
+postponed until earliest time when next flush is allowed.
+
+
+== SynCache DRb Server
+
+SynCache::Cache object can be shared between multiple Ruby processes,
+even across different computers. All you need is the
+<tt>syncache-drb</tt> script shipped with this module. This script will
+start a daemon that serves a SynCache::Cache object over dRuby protocol,
+with $SAFE set to 1 for security.
+
+To access a remote cache, you will need to use DRb library:
+
+  require 'drb'
+
+  # connect to the remote cache
+  @cache = DRbObject.new_with_uri('druby://localhost:9000')
+
+  # allow remote cache to access local objects from fetch_or_add blocks
+  DRb.start_service('druby://localhost:0')
+
+
+== Copying
+
+  Copyright (c) 2002-2009  Dmitry Borodaenko <angdraug@debian.org>
+
+  This program is free software.
+  You can distribute/modify this program under the terms of the GNU
+  General Public License version 3 or later.
+  
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "syncache"
+    gem.summary = %Q{SynCache is a thread-safe time-limited cache with flexible replacement policy and ability to wrap generation of expensive cache entries in synchronized blocks. SynCache was used in the Samizdat open publishing engine since 2005, and now it's released as a stand-alone module ready for use in other applications.}
+    gem.description = %Q{SynCache::Cache stores cached objects in a Hash that is protected by an advanced two-level locking mechanism. Two-level locking ensures that:
+
+        * Multiple threads can add and fetch objects in parallel without stepping on each other's toes.
+        * While one thread is working on a cache entry, other threads can access the rest of the cache with no waiting on the global lock, no race conditions nor deadlock or livelock situations.
+        * While one thread is performing a long and resource-intensive operation, other threads that request the same data with fetch_or_add() method will be put on hold, and as soon as the first thread completes the operation, the result will be returned to all threads. Without this feature, a steady stream of requests with less time between them than it takes to complete one request can easily bury a server under an avalanche of threads all wasting resources on the same expensive operation.
+
+    When number of cache entries exceeds the size limit, the least recently accessed entries are replaced with new data. This replacement strategy is controlled by the SynCache::CacheEntry class and can be changed by overriding its replacement_index() method.
+
+    Cache entries are automatically invalidated when their ttl (time to live) is exceeded. Entries can be explicitly invalidated by flush() method. The method can use === operator to compare cache keys against flush base (so that base can be e.g. a Regexp), and invalidates all entries when invoked without the base parameter.
+
+    The flush_delay initialization option allows to limit cache's flush rate. When this option is set, SynCache will make sure that at least this many seconds (it can also be a fraction) pass between two flushes. When extra flushes are requested, invalidation of flushed entries is postponed until earliest time when next flush is allowed.
+    }
+    gem.email = "angdraug@debian.org"
+    gem.homepage = "http://github.com/czarneckid/syncache"
+    gem.authors = ["Dmitry Borodaenko", "David Czarnecki"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "syncache #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/syncache.rb

@@ -0,0 +1,258 @@
+# SynCache: thread-safe time-limited cache with flexible replacement policy
+# (originally written for Samizdat project)
+#
+#   Copyright (c) 2002-2009  Dmitry Borodaenko <angdraug@debian.org>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 3 or later.
+#
+# vim: et sw=2 sts=2 ts=8 tw=0
+
+require 'sync'
+require 'syncache_sync_patch'
+
+module SynCache
+
+FOREVER = 60 * 60 * 24 * 365 * 5   # 5 years
+
+class CacheEntry
+  def initialize(ttl = nil, value = nil)
+    @value = value
+    @ttl = ttl
+    @dirty = false
+    record_access
+
+    @sync = Sync.new
+  end
+
+  # stores the value object
+  attr_accessor :value
+
+  # change this to make the entry expire sooner
+  attr_accessor :ttl
+
+  # use this to synchronize access to +value+
+  attr_reader :sync
+
+  # record the fact that the entry was accessed
+  #
+  def record_access
+    return if @dirty
+    @expires = Time.now + (@ttl or FOREVER)
+  end
+
+  # entries with lowest index will be replaced first
+  #
+  def replacement_index
+    @expires
+  end
+
+  # check if entry is stale
+  #
+  def stale?
+    @expires < Time.now
+  end
+
+  # mark entry as dirty and schedule it to expire at given time
+  #
+  def expire_at(time)
+    @expires = time if @expires > time
+    @dirty = true
+  end
+end
+
+class Cache
+
+  # set to _true_ to report every single cache operation to syslog
+  #
+  DEBUG = false
+
+  # a float number of seconds to sleep when a race condition is detected
+  # (actual delay is randomized to avoid live lock situation)
+  #
+  LOCK_SLEEP = 0.2
+
+  # _ttl_ (time to live) is time in seconds from the last access until cache
+  # entry is expired (set to _nil_ to disable time limit)
+  # 
+  # _max_size_ is max number of objects in cache
+  #
+  # _flush_delay_ is used to rate-limit flush operations: if less than that
+  # number of seconds has passed since last flush, next flush will be delayed;
+  # default is no rate limit
+  #
+  def initialize(ttl = 60*60, max_size = 5000, flush_delay = nil)
+    @ttl = ttl
+    @max_size = max_size
+
+    if @flush_delay = flush_delay
+      @last_flush = Time.now
+    end
+
+    @sync = Sync.new
+    @cache = {}
+  end
+
+  # remove all values from cache
+  #
+  # if _base_ is given, only values with keys matching the base (using
+  # <tt>===</tt> operator) are removed
+  #
+  def flush(base = nil)
+    debug('flush ' << base.to_s)
+
+    @sync.synchronize do
+
+      if @flush_delay
+        next_flush = @last_flush + @flush_delay
+
+        if next_flush > Time.now
+          flush_at(next_flush, base)
+        else
+          flush_now(base)
+          @last_flush = Time.now
+        end
+
+      else
+        flush_now(base)
+      end
+    end
+  end
+
+  # remove single value from cache
+  #
+  def delete(key)
+    debug('delete ' << key.to_s)
+
+    @sync.synchronize do
+      @cache.delete(key)
+    end
+  end
+
+  # store new value in cache
+  #
+  # see also Cache#fetch_or_add
+  #
+  def []=(key, value)
+    debug('[]= ' << key.to_s)
+
+    entry = get_entry(key)
+    entry.sync.synchronize do
+      entry.value = value
+    end
+    value
+  end
+
+  # retrieve value from cache if it's still fresh
+  #
+  # see also Cache#fetch_or_add
+  #
+  def [](key)
+    debug('[] ' << key.to_s)
+
+    entry = get_entry(key)
+    entry.sync.synchronize(:SH) do
+      entry.value
+    end
+  end
+
+  # initialize missing cache entry from supplied block
+  #
+  # this is the preferred method of adding values to the cache as it locks the
+  # key for the duration of computation of the supplied block to prevent
+  # parallel execution of resource-intensive actions
+  #
+  def fetch_or_add(key)
+    debug('fetch_or_add ' << key.to_s)
+
+    entry = nil   # scope fix
+    entry_locked = false
+    until entry_locked do
+      @sync.synchronize do
+        entry = get_entry(key)
+        entry_locked = entry.sync.try_lock   # fixme
+      end
+      sleep(rand * LOCK_SLEEP) unless entry_locked
+    end
+
+    begin
+      entry.record_access
+      entry.value ||= yield
+    ensure
+      entry.sync.unlock
+    end
+  end
+
+  private
+
+  # immediate flush (delete all entries matching _base_)
+  #
+  # must be run from inside global lock, see #flush
+  #
+  def flush_now(base = nil)
+    if base
+      @cache.delete_if {|key, entry| base === key }
+    else
+      @cache = {}
+    end
+  end
+
+  # delayed flush (ensure all entries matching _base_ expire no later than _next_flush_)
+  #
+  # must be run from inside global lock, see #flush
+  #
+  def flush_at(next_flush, base = nil)
+    @cache.each do |key, entry|
+      next if base and not base === key
+      entry.expire_at(next_flush)
+    end
+  end
+
+  def get_entry(key)
+    debug('get_entry ' << key.to_s)
+
+    @sync.synchronize do
+      entry = @cache[key]
+
+      if entry.kind_of?(CacheEntry)
+        if entry.stale?
+          @cache[key] = entry = CacheEntry.new(@ttl)
+        end
+      else
+        @cache[key] = entry = CacheEntry.new(@ttl)
+        check_size
+      end
+
+      entry.record_access
+      entry
+    end
+  end
+
+  # remove oldest item from cache if size limit reached
+  #
+  def check_size
+    debug('check_size')
+
+    return unless @max_size.kind_of? Numeric
+
+    @sync.synchronize do
+      while @cache.size > @max_size do
+        # optimize: supplement hash with queue
+        oldest = @cache.keys.min {|a, b| @cache[a].replacement_index <=> @cache[b].replacement_index }
+
+        @cache.delete(oldest)
+      end
+    end
+  end
+
+  # send debug output to syslog if enabled
+  #
+  def debug(message)
+    if DEBUG and defined?(Syslog) and Syslog.opened?
+      Syslog.debug(Thread.current.to_s << ' ' << message)
+    end
+  end
+end
+
+end   # module SynCache

data/lib/syncache_sync_patch.rb

@@ -0,0 +1,36 @@
+# Monkey patch for standard sync.rb (see bug #11680 on RubyForge).
+
+if RUBY_VERSION < "1.8.7" or (RUBY_VERSION == "1.8.7" and RUBY_PATCHLEVEL < 173)
+
+module Sync_m
+  class Err < StandardError
+    def Err.Fail(*opt)
+      Thread.critical = false
+      fail self, sprintf(self::Message, *opt)
+    end
+  end
+
+  def sync_try_lock(mode = EX)
+    return unlock if mode == UN
+
+    Thread.critical = true
+    ret = sync_try_lock_sub(mode)
+    Thread.critical = false
+    ret
+  end
+end
+
+elsif RUBY_VERSION == "1.9.0"
+
+module Sync_m
+  def sync_try_lock(mode = EX)
+    return unlock if mode == UN
+    ret = nil
+    @sync_mutex.synchronize do
+      ret = sync_try_lock_sub(mode)
+    end
+    ret
+  end
+end
+
+end

data/syncache.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{syncache}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dmitry Borodaenko", "David Czarnecki"]
+  s.date = %q{2010-05-06}
+  s.description = %q{SynCache::Cache stores cached objects in a Hash that is protected by an advanced two-level locking mechanism. Two-level locking ensures that:
+
+        * Multiple threads can add and fetch objects in parallel without stepping on each other's toes.
+        * While one thread is working on a cache entry, other threads can access the rest of the cache with no waiting on the global lock, no race conditions nor deadlock or livelock situations.
+        * While one thread is performing a long and resource-intensive operation, other threads that request the same data with fetch_or_add() method will be put on hold, and as soon as the first thread completes the operation, the result will be returned to all threads. Without this feature, a steady stream of requests with less time between them than it takes to complete one request can easily bury a server under an avalanche of threads all wasting resources on the same expensive operation.
+
+    When number of cache entries exceeds the size limit, the least recently accessed entries are replaced with new data. This replacement strategy is controlled by the SynCache::CacheEntry class and can be changed by overriding its replacement_index() method.
+
+    Cache entries are automatically invalidated when their ttl (time to live) is exceeded. Entries can be explicitly invalidated by flush() method. The method can use === operator to compare cache keys against flush base (so that base can be e.g. a Regexp), and invalidates all entries when invoked without the base parameter.
+
+    The flush_delay initialization option allows to limit cache's flush rate. When this option is set, SynCache will make sure that at least this many seconds (it can also be a fraction) pass between two flushes. When extra flushes are requested, invalidation of flushed entries is postponed until earliest time when next flush is allowed.
+    }
+  s.email = %q{angdraug@debian.org}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/syncache.rb",
+     "lib/syncache_sync_patch.rb",
+     "syncache.gemspec",
+     "test/helper.rb",
+     "test/test_syncache.rb"
+  ]
+  s.homepage = %q{http://github.com/czarneckid/syncache}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{SynCache is a thread-safe time-limited cache with flexible replacement policy and ability to wrap generation of expensive cache entries in synchronized blocks. SynCache was used in the Samizdat open publishing engine since 2005, and now it's released as a stand-alone module ready for use in other applications.}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_syncache.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'syncache'
+
+class Test::Unit::TestCase
+end

data/test/test_syncache.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+#
+# SynCache tests
+#
+#   Copyright (c) 2002-2009  Dmitry Borodaenko <angdraug@debian.org>
+#
+#   This program is free software.
+#   You can distribute/modify this program under the terms of
+#   the GNU General Public License version 3 or later.
+#
+# vim: et sw=2 sts=2 ts=8 tw=0
+
+require 'helper'
+
+include SynCache
+
+class TC_Cache < Test::Unit::TestCase
+
+  def test_initialize
+    cache = Cache.new(3, 5)
+  end
+
+  def test_flush
+    cache = Cache.new(3, 5)
+    cache['t'] = 'test'
+    cache.flush
+    assert_equal nil, cache['t']
+  end
+
+  def test_add_fetch
+    cache = Cache.new(3, 5)
+    cache['t'] = 'test'
+    assert_equal 'test', cache['t']
+  end
+
+  def test_fetch_or_add
+    cache = Cache.new(3, 5)
+    assert_equal nil, cache['t']
+    cache.fetch_or_add('t') { 'test' }
+    assert_equal 'test', cache['t']
+  end
+
+  def test_truncate
+    cache = Cache.new(3, 5)
+    1.upto(5) {|i| cache[i] = i }
+    1.upto(5) do |i|
+      assert_equal i, cache[i]
+    end
+    6.upto(10) {|i| cache[i] = i }
+    1.upto(5) do |i|
+      assert_equal nil, cache[i]
+    end
+  end
+
+  def test_timeout
+    cache = Cache.new(0.01, 5)
+    1.upto(5) {|i| cache[i] = i }
+    1.upto(5) do |i|
+      assert_equal i, cache[i]
+    end
+    sleep(0.02)
+    1.upto(5) do |i|
+      assert_equal nil, cache[i]
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: syncache
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Dmitry Borodaenko
+- David Czarnecki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-06 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: "SynCache::Cache stores cached objects in a Hash that is protected by an advanced two-level locking mechanism. Two-level locking ensures that:\n\n        * Multiple threads can add and fetch objects in parallel without stepping on each other's toes.\n        * While one thread is working on a cache entry, other threads can access the rest of the cache with no waiting on the global lock, no race conditions nor deadlock or livelock situations.\n        * While one thread is performing a long and resource-intensive operation, other threads that request the same data with fetch_or_add() method will be put on hold, and as soon as the first thread completes the operation, the result will be returned to all threads. Without this feature, a steady stream of requests with less time between them than it takes to complete one request can easily bury a server under an avalanche of threads all wasting resources on the same expensive operation.\n\n    When number of cache entries exceeds the size limit, the least recently accessed entries are replaced with new data. This replacement strategy is controlled by the SynCache::CacheEntry class and can be changed by overriding its replacement_index() method.\n\n    Cache entries are automatically invalidated when their ttl (time to live) is exceeded. Entries can be explicitly invalidated by flush() method. The method can use === operator to compare cache keys against flush base (so that base can be e.g. a Regexp), and invalidates all entries when invoked without the base parameter.\n\n    The flush_delay initialization option allows to limit cache's flush rate. When this option is set, SynCache will make sure that at least this many seconds (it can also be a fraction) pass between two flushes. When extra flushes are requested, invalidation of flushed entries is postponed until earliest time when next flush is allowed.\n    "
+email: angdraug@debian.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/syncache.rb
+- lib/syncache_sync_patch.rb
+- syncache.gemspec
+- test/helper.rb
+- test/test_syncache.rb
+has_rdoc: true
+homepage: http://github.com/czarneckid/syncache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: SynCache is a thread-safe time-limited cache with flexible replacement policy and ability to wrap generation of expensive cache entries in synchronized blocks. SynCache was used in the Samizdat open publishing engine since 2005, and now it's released as a stand-alone module ready for use in other applications.
+test_files: 
+- test/helper.rb
+- test/test_syncache.rb