cutest-cj 1.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a68e884e7e86738b74f543cf51d04ea3317e8c77
+  data.tar.gz: 8155aa435a1c9193a28fb93e410adfd4f83e702d
+SHA512:
+  metadata.gz: 50fd8d32c88a67c4c1adb9683436393e16572c52bb2244be9d7a6b169cbe135069358d96f25f0aecde655d39f176df02aed37211144862d4c52dd7ddbeb5f06f
+  data.tar.gz: abd4cd45d72285f1fb6a345dfe3fbd400142dbdd5b4d54403d995fa758d95dcdb206b2f3c6e9415979a6ea3b1a5becf773913ef22e113df3b013656a1aa886d8

data/.gitignore

@@ -0,0 +1 @@
+/pkg

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+1.2.1 - 2013-08-14
+==================
+
+* `cutest(1)` now exits with a non-zero status when a test fails.
+
+Previous versions
+=================
+
+Check the commit list for earlier changes.

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Damian Janowski & Michel Martens
+
+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.markdown

@@ -0,0 +1,167 @@
+Cutest
+=======
+
+Forking tests.
+
+Description
+-----------
+
+Each test file is run in a forked process to avoid shared state. Once a failure
+is found, you get a report detailing what failed and how to locate the error
+and the rest of the file is skipped.
+
+You can use the `scope` command around tests: it guarantees that no instance
+variables are shared between tests.
+
+There are two commands very similar in nature, but with a subtle difference that
+makes them easy to combine in order to satisfy different needs: `prepare` and
+`setup`.
+
+The `prepare` blocks are executed before each test. If you call `prepare` many
+times, each passed block is appended to an array. When the test is run, all
+those prepare blocks are executed in order. The result of the block is
+discarded, so it is only useful for preparing the environment (flushing the
+database, removing a directory, etc.).
+
+The `setup` block is executed before each test and the result is passed as a
+parameter to the `test` block. Unlike `prepare`, each definition of `setup`
+overrides the previous one. Even if you can declare instance variables and
+share them between tests, the recommended usage is to pass the result of the
+block as a parameter to the `test` blocks.
+
+The `test` method executes the passed block after running `prepare` and
+`setup`. This is where assertions must be declared.
+
+Three assertions are available: `assert`, that accepts a value and raises
+if it's false or nil; `assert_equal`, that raises if its arguments are not
+equal; and `assert_raise`, that executes a passed block and compares the raised
+exception to the expected one. In all cases, if the expectation is no met, an
+`AssertionFailed` exception is raised.
+
+Usage
+-----
+
+In your terminal:
+
+    $ cutest test/*.rb
+
+In your tests:
+
+    setup do
+      {:a => 23, :b => 43}
+    end
+
+    test "should receive the result of the setup block as a parameter" do |params|
+      assert params == {:a => 23, :b => 43}
+    end
+
+    test "should evaluate the setup block before each test" do |params|
+      params[:a] = nil
+    end
+
+    test "should preserve the original values from the setup" do |params|
+      assert 23 == params[:a]
+    end
+
+An example working with a prepare block:
+
+    prepare do
+      Ohm.flush
+    end
+
+    setup do
+      Ohm.redis.get("foo")
+    end
+
+    test do |foo|
+      assert foo.nil?
+    end
+
+And working with scopes:
+
+    setup do
+      @foo = true
+    end
+
+    @bar = true
+
+    scope do
+      test "should not share instance variables" do |foo|
+        assert !defined?(@foo)
+        assert !defined?(@bar)
+        assert foo == true
+      end
+    end
+
+The tests in these two examples will pass.
+
+Unlike other testing frameworks, Cutest does not compile all the tests before
+running them.
+
+Handling errors
+---------------
+
+If you get an error when running the tests, this is what you will see:
+
+    Exception: assert_equal 24, params[:a] # 24 != 23
+    test/setup.rb +14
+
+Running the build
+-----------------
+
+Using Rake:
+
+    task :test do
+      exec "cutest test/*.rb"
+    end
+
+    task :default => :test
+
+Using Make:
+
+    .PHONY: test
+
+    test:
+      cutest test/*.rb
+
+Command-line interface
+----------------------
+
+The tool `cutest` accepts a list of files and sends them to `Cutest.run`. If
+you need to require a file or library before running the tests, as is the case
+with test helpers, use the `-r` flag:
+
+    $ cutest -r ./test/helper.rb ./test/*_test.rb
+
+If you want to check which version you are running, try the `-v` flag.
+
+Installation
+------------
+
+    $ gem install cutest
+
+License
+-------
+
+Copyright (c) 2010 Damian Janowski and Michel Martens
+
+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,9 @@
+require File.expand_path("../lib/cutest", __FILE__)
+
+$VERBOSE = true
+
+task :test do
+  Cutest.run(Dir["test/*.rb"])
+end
+
+task :default => :test

data/bin/cutest

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+if ARGV.empty?
+  puts "usage: cutest [-r lib] [-v] file [-b (backtrace) [-p (pry rescue)]]"
+  exit
+end
+
+require_relative "../lib/cutest"
+require_relative "../lib/cutest/vendor/clap"
+
+files = Clap.run ARGV,
+  "-r"      => lambda { |file| require file },
+  "-t"      => lambda { |name| cutest[:only] = name },
+  "-s"      => lambda { |name| cutest[:scope] = name },
+  "-b"      => lambda { cutest[:backtrace] = true },
+  "-p"      => lambda { ENV['PRY_RESCUE'] = 'true'; cutest[:pry_rescue] = true },
+  "-v"      => lambda { puts Cutest::VERSION }
+
+if files.any?
+  begin
+    success = Cutest.run(Dir[*files])
+
+    exit(1) unless success
+  rescue ThreadError
+    # Ignore this as it's caused by Process.waitall when using -p
+  end
+end

data/cutest.gemspec

@@ -0,0 +1,20 @@
+require "./lib/cutest"
+
+Gem::Specification.new do |s|
+  s.name              = "cutest-cj"
+  s.version           = Cutest::VERSION
+  s.summary           = "Forking tests."
+  s.description       = "Run tests in separate processes to avoid shared state."
+  s.authors           = ["Damian Janowski", "Michel Martens", "Cyril David"]
+  s.email             = ["djanowski@dimaion.com", "michel@soveran.com", "me@cyrildavid.com"]
+  s.homepage          = "https://github.com/djanowski/cutest"
+
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.executables.push "cutest"
+
+  s.add_dependency 'pry-rescue'
+  s.add_dependency 'pry-stack_explorer'
+end

data/lib/cutest/vendor/clap.rb

@@ -0,0 +1,46 @@
+class Clap
+  attr :argv
+  attr :opts
+
+  def self.run(args, opts)
+    new(args, opts).run
+  end
+
+  def initialize(argv, opts)
+    @argv = argv.dup
+    @opts = opts
+  end
+
+  def run
+    args = []
+
+    while argv.any?
+
+      item = argv.shift
+      flag = opts[item]
+
+      if flag
+
+        # Work around lambda semantics in 1.8.7.
+        arity = [flag.arity, 0].max
+
+        # Raise if there are not enough parameters
+        # available for the flag.
+        if argv.size < arity
+          raise ArgumentError
+        end
+
+        # Call the lambda with N items from argv,
+        # where N is the lambda's arity.
+        flag.call(*argv.shift(arity))
+      else
+
+        # Collect the items that don't correspond to
+        # flags.
+        args << item
+      end
+    end
+
+    args
+  end
+end

data/lib/cutest.rb

@@ -0,0 +1,217 @@
+require 'benchmark'
+
+class Cutest
+  unless defined?(VERSION)
+    VERSION = "1.2.2"
+    FILTER = %r[/(ruby|jruby|rbx)[-/]([0-9\.])+]
+    CACHE = Hash.new { |h, k| h[k] = File.readlines(k) }
+  end
+
+  def self.run(files)
+    status = files.all? do |file|
+      run_file(file)
+
+      if not cutest[:pry_rescue]
+        Process.wait
+        $?.success?
+      else
+        begin
+          Process.waitall
+        rescue ThreadError, Interrupt
+          # Ignore this as it's caused by Process.waitall when using -p
+        end
+      end
+    end
+
+    puts
+
+    status
+  end
+
+  def self.run_file(file)
+    fork do
+      begin
+        load(file)
+      rescue LoadError, SyntaxError
+        display_error
+        exit 1
+
+      rescue StandardError
+        trace = $!.backtrace
+        pivot = trace.index { |line| line.match(file) }
+
+        puts "\n     \e[93mTest: \e[0m%s\e[31m✘\e[0m\n" % (cutest[:test] != '' ? "#{cutest[:test]} " : '')
+
+        if pivot
+          other = trace[0..pivot].select { |line| line !~ FILTER }
+          other.reverse.each { |line| display_trace(line) }
+        else
+          display_trace(trace.first)
+        end
+
+        display_error
+
+        if not cutest[:pry_rescue]
+          exit 1
+        else
+          begin
+            Process.waitall
+          rescue ThreadError, Interrupt
+            # Ignore this as it's caused by Process.waitall when using -p
+          end
+        end
+      end
+    end
+  end
+
+  def self.code(fn, ln)
+    begin
+      CACHE[fn][ln.to_i - 1].strip
+    rescue
+      "(Can't display line)"
+    end
+  end
+
+  def self.display_error
+    if cutest[:backtrace]
+      bt = $!.backtrace
+      bt.each do |line|
+        display_trace line
+      end
+    end
+
+    print "     \033[93m#{$!.class}: "
+    print "\033[31m#{$!.message}\n"
+  end
+
+  def self.display_trace(line)
+    fn, ln = line.split(":")
+
+    puts "     → \033[0mfile: #{fn} ↪#{ln}\e[0m"
+    puts "     → \033[90mline: #{code(fn, ln)}\e[0m"
+  end
+
+  class AssertionFailed < StandardError
+  end
+
+  class Scope
+    def initialize(&scope)
+      @scope = scope
+    end
+
+    def call
+      instance_eval(&@scope)
+    end
+  end
+end
+
+module Kernel
+private
+
+  # Use Thread.current[:cutest] to store information about test preparation
+  # and setup.
+  Thread.current[:cutest] ||= { :prepare => [] }
+
+  # Shortcut to access Thread.current[:cutest].
+  def cutest
+    Thread.current[:cutest]
+  end
+
+  # Create a class where the block will be evaluated. Recommended to improve
+  # isolation between tests.
+  def scope(name = nil, &block)
+    cutest[:current_scope] = name
+    return if cutest[:scope] and cutest[:scope] != cutest[:current_scope]
+
+    print "\n   \033[93mScope: \033[0m#{cutest[:current_scope]}\n\n     "
+    Cutest::Scope.new(&block).call
+  end
+
+  # Prepare the environment in order to run the tests. This method can be
+  # called many times, and each new block is appended to a list of
+  # preparation blocks. When a test is executed, all the preparation blocks
+  # are ran in the order they were declared. If called without a block, it
+  # returns the array of preparation blocks.
+  def prepare(&block)
+    cutest[:prepare] << block if block_given?
+    cutest[:prepare]
+  end
+
+  # Setup parameters for the tests. The block passed to setup is evaluated
+  # before running each test, and the result of the setup block is passed to
+  # the test as a parameter. If the setup and the tests are declared at the
+  # same level (in the global scope or in a sub scope), it is possible to use
+  # instance variables, but the parameter passing pattern is recommended to
+  # ensure there are no side effects.
+  #
+  # If the setup blocks are declared in the global scope and the tests are
+  # declared in sub scopes, the parameter passing usage is required.
+  #
+  # Setup blocks can be defined many times, but each new definition overrides
+  # the previous one. It is recommended to split the tests in many different
+  # files (the report is per file, not per assertion). Usually one setup
+  # block per file is enough, but nothing forbids having different scopes
+  # with different setup blocks.
+  def setup(&block)
+    cutest[:setup] = block if block_given?
+    cutest[:setup]
+  end
+
+  # Kernel includes a test method for performing tests on files.
+  undef test if defined? test
+
+  # Call the prepare and setup blocks before executing the test. Even
+  # though the assertions can live anywhere (it's not mandatory to put them
+  # inside test blocks), it is necessary to wrap them in test blocks in order
+  # to execute preparation and setup blocks.
+  def test(name = nil, &block)
+    cutest[:test] = name
+
+    if !cutest[:scope] || cutest[:scope] == cutest[:current_scope]
+      if !cutest[:only] || cutest[:only] == name
+        time_taken = Benchmark.measure do
+          prepare.each { |blk| blk.call }
+          block.call(setup && setup.call)
+        end
+        print "     \n     \033[93mTest: \033[0m#{cutest[:test]} \033[32m✔\033[0m\n   \e[94m#{time_taken}\033[0m\n     "
+      end
+    end
+  end
+
+  # Assert that value is not nil or false.
+  def assert(value)
+    flunk("expression returned #{value.inspect}") unless value
+    success
+  end
+
+  # Assert that two values are equal.
+  def assert_equal(value, other)
+    flunk("#{value.inspect} != #{other.inspect}") unless value == other
+    success
+  end
+
+  # Assert that the block doesn't raise the expected exception.
+  def assert_raise(expected = Exception)
+    begin
+      yield
+    rescue => exception
+    ensure
+      flunk("got #{exception.inspect} instead") unless exception.kind_of?(expected)
+      success
+    end
+  end
+
+  # Stop the tests and raise an error where the message is the last line
+  # executed before flunking.
+  def flunk(message = nil)
+    exception = Cutest::AssertionFailed.new(message)
+    exception.set_backtrace([caller[1]])
+
+    raise exception
+  end
+
+  # Executed when an assertion succeeds.
+  def success
+    print "•"
+  end
+end

data/test/assert.rb

@@ -0,0 +1,9 @@
+test "succeeds if the value is true" do
+  assert true
+end
+
+test "raises if the assertion fails" do
+  assert_raise(Cutest::AssertionFailed) do
+    assert false
+  end
+end

data/test/assert_equal.rb

@@ -0,0 +1,9 @@
+test  do
+  assert_equal 1, 1
+end
+
+test "raises if the assertion fails" do
+  assert_raise(Cutest::AssertionFailed) do
+    assert_equal 1, 2
+  end
+end

data/test/assert_raise.rb

@@ -0,0 +1,13 @@
+test "catches the right exception" do
+  assert_raise(RuntimeError) do
+    raise RuntimeError
+  end
+end
+
+test "raises if the expectation is not met" do
+  assert_raise(Cutest::AssertionFailed) do
+    assert_raise(RuntimeError) do
+      raise ArgumentError
+    end
+  end
+end

data/test/fixtures/exception.rb

@@ -0,0 +1,7 @@
+def foo
+  raise "Oops"
+end
+
+test "some unhandled exception" do
+  foo
+end

data/test/fixtures/fail_custom_assertion.rb

@@ -0,0 +1,8 @@
+def assert_empty(string)
+  flunk("not empty") unless string.empty?
+  success
+end
+
+test "failed custom assertion" do
+  assert_empty "foo"
+end

data/test/fixtures/failure.rb

@@ -0,0 +1,3 @@
+test "failed assertion" do
+  assert false
+end

data/test/fixtures/failure_in_loaded_file.rb

@@ -0,0 +1 @@
+load("test/fixtures/failure.rb")

data/test/fixtures/only_run_given_scope_name.rb

@@ -0,0 +1,25 @@
+test do
+  raise "This is not raised"
+end
+
+scope "scope" do
+  test do
+    assert true
+  end
+end
+
+scope "another scope" do
+  test do
+    raise "This is not raised"
+  end
+end
+
+scope "scope" do
+  test "test" do
+    assert true
+  end
+
+  test do
+    raise "This is raised"
+  end
+end

data/test/fixtures/success.rb

@@ -0,0 +1,7 @@
+def foo
+  raise "Invalid code"
+end
+
+test "external exceptions" do
+  assert true
+end

data/test/prepare.rb

@@ -0,0 +1,25 @@
+prepare do
+  $foo = []
+end
+
+prepare do
+  $foo << true
+end
+
+test "all the prepare blocks are called" do
+  assert $foo == [true]
+end
+
+prepare do
+  $foo << false
+end
+
+test "and are cumulative" do
+  assert $foo == [true, false]
+end
+
+scope do
+  test "and run inside scopes" do
+    assert $foo = [true, false]
+  end
+end

data/test/run.rb

@@ -0,0 +1,78 @@
+test "output of successful run" do
+  expected = ".\n"
+
+  out = %x{./bin/cutest test/fixtures/success.rb}
+
+  assert_equal(expected, out)
+end
+
+test "exit code of successful run" do
+  %x{./bin/cutest test/fixtures/success.rb}
+  assert_equal 0, $?.to_i
+end
+
+test "output of failed run" do
+  expected = "\n" +
+             "  test: failed assertion\n" +
+             "  line: assert false\n" +
+             "  file: test/fixtures/failure.rb +2\n\n" +
+             "Cutest::AssertionFailed: expression returned false\n\n"
+
+  out = %x{./bin/cutest test/fixtures/failure.rb}
+
+  assert_equal(expected, out)
+end
+
+test "output of failed run" do
+  expected = "\n" +
+             "  test: some unhandled exception\n" +
+             "  line: raise \"Oops\"\n" +
+             "  file: test/fixtures/exception.rb +2\n\n" +
+             "RuntimeError: Oops\n\n"
+
+  out = %x{./bin/cutest test/fixtures/exception.rb}
+
+  assert_equal(expected, out)
+end
+
+test "exit code of failed run" do
+  %x{./bin/cutest test/fixtures/failure.rb}
+
+  assert $?.to_i != 0
+end
+
+test "output of custom assertion" do
+  expected = "\n" +
+             "  test: failed custom assertion\n" +
+             "  line: assert_empty \"foo\"\n" +
+             "  file: test/fixtures/fail_custom_assertion.rb +7\n\n" +
+             "Cutest::AssertionFailed: not empty\n\n"
+
+  out = %x{./bin/cutest test/fixtures/fail_custom_assertion.rb}
+
+  assert_equal(expected, out)
+end
+
+test "output of failure in nested file" do
+  expected = "\n" +
+             "  test: failed assertion\n" +
+             "  line: assert false\n" +
+             "  file: test/fixtures/failure.rb +2\n\n" +
+             "Cutest::AssertionFailed: expression returned false\n\n"
+
+  out = %x{./bin/cutest test/fixtures/failure_in_loaded_file.rb}
+
+  assert_equal(expected, out)
+end
+
+test "only runs given scope name" do
+  out = %x{./bin/cutest test/fixtures/only_run_given_scope_name.rb -s scope}
+
+  assert out =~ /This is raised/
+end
+
+test "runs by given scope and test names" do
+  %x{./bin/cutest test/fixtures/only_run_given_scope_name.rb -s scope -o test}
+
+  assert_equal 0, $?.to_i
+end

data/test/scopes.rb

@@ -0,0 +1,27 @@
+@bar = true
+
+scope do
+  @foo = true
+
+  test "something" do
+    assert defined?(@foo)
+    assert !defined?(@bar)
+  end
+end
+
+scope do
+  test "something" do
+    assert !defined?(@foo)
+    assert !defined?(@bar)
+  end
+end
+
+scope do
+  @baz = true
+
+  scope do
+    test "something" do
+      assert !defined?(@baz)
+    end
+  end
+end

data/test/setup.rb

@@ -0,0 +1,29 @@
+setup do
+  {:a => 23, :b => 43}
+end
+
+test "should receive the result of the setup block as a parameter" do |params|
+  assert params == {:a => 23, :b => 43}
+end
+
+test "if the params are modified..." do |params|
+  params[:a] = nil
+end
+
+test "...it should preserve the original values from the setup" do |params|
+  assert_equal 23, params[:a]
+end
+
+setup do
+  "Hello world!"
+end
+
+test "only the most recently defined setup block is executed" do |value|
+  assert "Hello world!" == value
+end
+
+scope do
+  test "works inside scopes too" do |value|
+    assert "Hello world!" == value
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: cutest-cj
+version: !ruby/object:Gem::Version
+  version: 1.2.2
+platform: ruby
+authors:
+- Damian Janowski
+- Michel Martens
+- Cyril David
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Run tests in separate processes to avoid shared state.
+email:
+- djanowski@dimaion.com
+- michel@soveran.com
+- me@cyrildavid.com
+executables:
+- cutest
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- LICENSE
+- README.markdown
+- Rakefile
+- bin/cutest
+- cutest.gemspec
+- lib/cutest.rb
+- lib/cutest/vendor/clap.rb
+- test/assert.rb
+- test/assert_equal.rb
+- test/assert_raise.rb
+- test/fixtures/exception.rb
+- test/fixtures/fail_custom_assertion.rb
+- test/fixtures/failure.rb
+- test/fixtures/failure_in_loaded_file.rb
+- test/fixtures/only_run_given_scope_name.rb
+- test/fixtures/success.rb
+- test/prepare.rb
+- test/run.rb
+- test/scopes.rb
+- test/setup.rb
+homepage: https://github.com/djanowski/cutest
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Forking tests.
+test_files: []
+has_rdoc: