oktest 1.0.2 → 1.2.1

data/README.md

@@ -4,12 +4,13 @@
 
 Oktest.rb is a new-style testing library for Ruby.
 
-* `ok {actual} == expected` style assertion.
-* **Fixture injection** inspired by dependency injection.
+* `ok {actual} == expected` style [assertion](#assertions).
+* [Fixture injection](#fixture-injection) inspired by dependency injection.
 * Structured test specifications like RSpec.
-* Filtering testcases by pattern or tags.
+* [JSON Matcher](#json-matcher) similar to JSON Schema.
+* [Filtering](#tag-and-filtering) testcases by pattern or tags.
 * Blue/red color instead of green/red for accesability.
-* Small code size (about 2400 lines) and good performance.
+* Small code size (less than 3000 lines) and good performance.
 
 ```ruby
 ### Oktest                           ### Test::Unit
@@ -42,7 +43,7 @@ Oktest.scope do                      #
 end                                  #
 ```
 
-Oktest.rb requires Ruby 2.3 or later.
+Oktest.rb requires Ruby 2.0 or later.
 
 
 
@@ -73,6 +74,7 @@ Oktest.rb requires Ruby 2.3 or later.
     * <a href="#at_end-crean-up-handler"><code>at_end()</code>: Crean-up Handler</a>
     * <a href="#named-fixtures">Named Fixtures</a>
     * <a href="#fixture-injection">Fixture Injection</a>
+    * <a href="#fixture-keyword-argument"><code>fixture:</code> keyword argument</a>
     * <a href="#global-scope">Global Scope</a>
   * <a href="#helpers">Helpers</a>
     * <a href="#capture_sio"><code>capture_sio()</code></a>
@@ -82,12 +84,19 @@ Oktest.rb requires Ruby 2.3 or later.
     * <a href="#dummy_attrs"><code>dummy_attrs()</code></a>
     * <a href="#dummy_ivars"><code>dummy_ivars()</code></a>
     * <a href="#recorder"><code>recorder()</code></a>
+    * <a href="#partial_regexp"><code>partial_regexp()</code></a>
+  * <a href="#json-matcher">JSON Matcher</a>
+    * <a href="#simple-example">Simple Example</a>
+    * <a href="#nested-example">Nested Example</a>
+    * <a href="#complex-example">Complex Example</a>
+    * <a href="#helper-methods-for-json-matcher">Helper Methods for JSON Matcher</a>
   * <a href="#tips">Tips</a>
     * <a href="#ok--in-minitest"><code>ok {}</code> in MiniTest</a>
     * <a href="#testing-rack-application">Testing Rack Application</a>
+    * <a href="#environment-variale-oktest_rb">Environment Variale <code>$OKTEST_RB</code></a>
     * <a href="#traverser-class">Traverser Class</a>
-    * <a href="#benchmarks">Benchmarks</a>
     * <a href="#--faster-option"><code>--faster</code> Option</a>
+    * <a href="#benchmarks">Benchmarks</a>
   * <a href="#change-log">Change Log</a>
   * <a href="#license-and-copyright">License and Copyright</a>
 
@@ -109,7 +118,7 @@ $ oktest --help
 $ mkdir test
 
 ### create test script
-$ oktest --create > test/example_test.rb
+$ oktest --skeleton > test/example_test.rb
 $ less test/example_test.rb
 
 ### run test script
@@ -165,6 +174,7 @@ Result:
 
 ```terminal
 $ oktest test/example01_test.rb   # or: ruby test/example01_test.rb
+## test/example01_test.rb
 * Hello
   * #hello()
     - [pass] returns greeting message.
@@ -206,6 +216,7 @@ Result:
 
 ```terminal
 $ oktest test/example02_test.rb   # or: ruby test/example02_test.rb
+## test/example02_test.rb
 * other examples
   - [Fail] example of assertion failure
   - [ERROR] example of something error
@@ -260,6 +271,7 @@ Result:
 
 ```terminal
 $ oktest test/example03_test.rb   # or: ruby test/example03_test.rb
+## oktest test/example03_test.rb
 * other examples
   - [Skip] example of skip (reason: requires Ruby3)
   - [TODO] example of todo
@@ -280,6 +292,7 @@ Verbose mode (default):
 
 ```terminal
 $ oktest test/example01_test.rb -s verbose  # or -sv
+## test/example01_test.rb
 * Hello
   * #hello()
     - [pass] returns greeting message.
@@ -291,6 +304,16 @@ Simple mode:
 
 ```terminal
 $ oktest test/example01_test.rb -s simple   # or -ss
+## test/example01_test.rb
+* Hello: 
+  * #hello(): ..
+## total:2 (pass:2, fail:0, error:0, skip:0, todo:0) in 0.000s
+```
+
+Compact mode:
+
+```terminal
+$ oktest test/example01_test.rb -s compact  # or -sc
 test/example01_test.rb: ..
 ## total:2 (pass:2, fail:0, error:0, skip:0, todo:0) in 0.000s
 ```
@@ -298,7 +321,7 @@ test/example01_test.rb: ..
 Plain mode:
 
 ```terminal
-$ oktest test/example01_test.rb -s simple   # or -ss
+$ oktest test/example01_test.rb -s plain    # or -sp
 ..
 ## total:2 (pass:2, fail:0, error:0, skip:0, todo:0) in 0.000s
 ```
@@ -315,6 +338,8 @@ Quiet mode reports progress only of failed or error test cases (and doesn't
 report progress of passed ones), so it's output is very compact. This is
 very useful for large project which contains large number of test cases.
 
+(Note: `ruby test/example01_test.rb -s <STYLE>` is also available.)
+
 
 ### Run All Test Scripts Under Directory
 
@@ -324,7 +349,7 @@ How to run test scripts under `test` directory:
 $ ls test/
 example01_test.rb       example02_test.rb       example03_test.rb
 
-$ oktest -s simple test  # or: ruby -r oktest -e 'Oktest.main' -- test -s simple
+$ oktest -s compact test  # or: ruby -r oktest -e 'Oktest.main' -- test -s compact
 test/example01_test.rb: ..
 test/example02_test.rb: fE
 ----------------------------------------------------------------------
@@ -457,6 +482,7 @@ Result:
 
 ```terminal
 $ ruby test/example05_test.rb
+## test/example05_test.rb
 * Integer
   * #abs()
     - When value is negative...
@@ -984,15 +1010,15 @@ end
 Result:
 
 ```terminal
-$ oktest -s plain test/example21_test.rb
+$ oktest -s quiet test/example21a_test.rb
 *** before_all() ***
 === before() ===
 ---- example spec #1 ----
 === after() ===
-.=== before() ===
+=== before() ===
 ---- example spec #2 ----
 === after() ===
-.*** after_all() ***
+*** after_all() ***
 
 ## total:2 (pass:2, fail:0, error:0, skip:0, todo:0) in 0.000s
 ```
@@ -1022,8 +1048,8 @@ Oktest.scope do
         after  { puts "===== Inner: after =====" }  # !!!!!
 
         spec "example" do
-	  ok {1+1} == 2
-	end
+          ok {1+1} == 2
+        end
 
       end
 
@@ -1209,12 +1235,42 @@ end
 -->
 
 
+### `fixture:` keyword argument
+
+`scope()` takes `fixture:` keyword argument which overwrites fixture value.
+
+test/example26_test.rb:
+
+```ruby
+require 'oktest'
+
+Oktest.scope do
+
+  fixture :user do |uname, uid: 101|   # `uid` is keyword param
+    {name: uname, id: uid}
+  end
+
+  fixture :uname do
+    "Alice"
+  end
+
+  ## keyword argument `fixture:` overwrites fixture values
+  spec "example", fixture: {uname: "Bob", uid: 201} do   # !!!!!
+    |user|
+    ok {user[:name]} == "Bob"    # != "Alice"
+    ok {user[:id]}   == 201      # != 101
+  end
+
+end
+```
+
+
 ### Global Scope
 
 It is a good idea to separate common fixtures into dedicated file.
 In this case, use `Oktest.global_scope()` instead of `Oktest.scope()`.
 
-test/common_fixtures.rb:
+test/example27_test.rb:
 
 ```ruby
 require 'oktest'
@@ -1588,6 +1644,334 @@ end
 ```
 
 
+### `partial_regexp()`
+
+`partial_regexp()` can embed regexp pattern into string, and compile it into Regexp object. This is very useful to validate multiline string with regexp.
+
+Assume that you are testing the following function `f1()`. It generates multiline string containing date and random string.
+
+```ruby
+def f1()
+  today  = Date.today.to_s                  # ex: '2021-12-31'
+  secret = Random.bytes(8).unpack('H*')[0]  # ex: "cd0b260ac728eda5"
+  return <<END
+* [config.date]   #{today}
+* [config.secret] #{secret}
+END
+end
+```ruby
+
+To test `f1()`, you may write the following test code.
+As you can see, expected regexp literal is complicated.
+
+```ruby
+  topic 'f1()' do
+    spec "generates multiline string." do
+      expected = /\A\* \[config\.date\]   \d\d\d\d-\d\d-\d\d\n\* \[config\.secret\] [0-9a-f]+\n/
+      ok {f1()} =~ expected
+    end
+  end
+```
+
+[`x` option](https://ruby-doc.org/core-2.7.0/Regexp.html#class-Regexp-label-Free-Spacing+Mode+and+Comments) of regexp (such as `/.../x`) allows you to write regexp literal in multiline format.
+But you have to escape metachars (`*`, `.`, `[]`, and white space).
+
+```ruby
+  topic 'f1()' do
+    spec "generates multiline string." do
+      expected = /\A
+\*\ \[config\.date\]\ \ \ \d\d\d\d-\d\d-\d\d\n
+\*\ \[config\.secret\]\ [0-9a-f]+\n
+\z/x      # !!!!!
+      ok {f1()} =~ expected
+    end
+  end
+```
+
+In such case, `partial_regexp()` is very useful. It compiles string into Regexp object.
+Using `partial_regexp()`, you can write expected regexp very easily.
+
+```ruby
+  topic 'f1()' do
+    spec "generates multiline string." do
+      # - Regexp can be in `{== ==}`.
+      # - Other text part is escaped by `Regexp.escape()`.
+      expected = partial_regexp <<'END'      # !!!!!
+* [config.date]   {== \d\d\d\d-\d\d-\d\d ==}
+* [config.secret] {== [0-9a-f]+ ==}
+END
+      ok {f1()} =~ expected
+      ## above is equivarent to:
+      #expected = /\A
+      #\*\ \[config\.date\]\ \ \ \d\d\d\d-\d\d-\d\d\n
+      #\*\ \[config\.secret\]\ [0-9a-f]+\n
+      #\z/x      # !!!!!
+      #ok {f1()} =~ expected
+    end
+  end
+```
+
+`partial_regexp()` takes 4 arguments.
+
+```ruby
+def partial_regexp(pattern, begin_='\A', end_='\z', mark='{== ==}')
+```
+
+`partial_regexp()` adds `\A` and `\z` automatically.
+If you want not to add them, pass empty string or nil as 2nd and 3rd argument, like this:
+
+```ruby
+partial_regexp <<-'END', '', ''    # !!!!!
+...
+END
+```
+
+If you want to change embed mark, specify 4th argument, like this:
+
+```ruby
+partial_regexp <<-'END', '\A', '\z', '%% %%'    # !!!!!
+* [config.date]   %% \d\d\d\d-\d\d-\d\d %%
+* [config.secret] %% [0-9a-f]+ %%
+END
+```
+
+Oktest.rb provides `partial_regexp!()`, too.
+Difference between `partial_regexp()` and `partial_regexp!()` is the result of `#inspect()`.
+This is imortant only when assertion failed and error message reported.
+You can use whichever you like.
+
+```ruby
+r1 = partial_regexp <<-'END'
+* [config.date]   {== \d\d\d\d-\d\d-\d\d ==}
+* [config.secret] {== [0-9a-f]+ ==}
+END
+p r1
+   #=> /\A
+   #   \*\ \[config\.date\]\ \ \ \d\d\d\d-\d\d-\d\d\n
+   #   \*\ \[config\.secret\]\ [0-9a-f]+\n
+   #   \z/x
+
+r2 = partial_regexp! <<-'END'                   # !!!!!
+* [config.date]   {== \d\d\d\d-\d\d-\d\d ==}
+* [config.secret] {== [0-9a-f]+ ==}
+END
+p r2
+   #=> partial_regexp(<<PREXP, '\A', '\z')
+   #   * [config.date]   {== \d\d\d\d-\d\d-\d\d ==}
+   #   * [config.secret] {== [0-9a-f]+ ==}
+   #   PREXP
+```
+
+
+## JSON Matcher
+
+Oktest.rb provides easy way to assert JSON data.
+This is very convenient feature, but don't abuse it.
+
+
+### Simple Example
+
+<!--
+test/example41_test.rb:
+-->
+```ruby
+require 'oktest'
+require 'set'                               # !!!!!
+
+Oktest.scope do
+  topic 'JSON Example' do
+
+    spec "simple example" do
+      actual = {
+        "name":     "Alice",
+        "id":       1001,
+        "age":      18,
+        "email":    "alice@example.com",
+        "gender":   "F",
+        "deleted":  false,
+        "tags":     ["aaa", "bbb", "ccc"],
+       #"twitter":  "@alice",
+      }
+      ## assertion
+      ok {JSON(actual)} === {               # requires `JSON()` and `===`
+        "name":     "Alice",                # scalar value
+        "id":       1000..9999,             # range object
+        "age":      Integer,                # class object
+        "email":    /^\w+@example\.com$/,   # regexp
+        "gender":   Set.new(["M", "F"]),    # Set object ("M" or "F")
+        "deleted":  Set.new([true, false]), # boolean (true or false)
+        "tags":     [/^\w+$/].each,         # Enumerator object (!= Array obj)
+        "twitter?": /^@\w+$/,               # key 'xxx?' means optional value
+      }
+    end
+
+  end
+end
+```
+
+(Note: Ruby 2.4 or older doesn't have `Set#===()`, so above code will occur error
+ in Ruby 2.4 or older. Please add the folllowing hack in your test script.)
+
+```ruby
+require 'set'
+unless Set.instance_methods(false).include?(:===)  # for Ruby 2.4 or older
+  class Set; alias === include?; end
+end
+```
+
+Notice that `Enumerator` has different meaning from `Array` in JSON matcher.
+
+```ruby
+  actual = {"tags": ["foo", "bar", "baz"]}
+
+  ## Array
+  ok {JSON(actual)} == {"tags": ["foo", "bar", "baz"]}
+
+  ## Enumerator
+  ok {JSON(actual)} == {"tags": [/^\w+$/].each}
+```
+
+
+### Nested Example
+
+<!--
+test/example42_test.rb:
+-->
+```ruby
+require 'oktest'
+require 'set'                            # !!!!!
+
+Oktest.scope do
+  topic 'JSON Example' do
+
+    spec "nested example" do
+      actual = {
+        "teams": [
+          {
+            "team": "Section 9",
+            "members": [
+              {"id": 2500, "name": "Aramaki", "gender": "M"},
+              {"id": 2501, "name": "Motoko" , "gender": "F"},
+              {"id": 2502, "name": "Batou"  , "gender": "M"},
+            ],
+            "leader": "Aramaki",
+          },
+          {
+            "team": "SOS Brigade",
+            "members": [
+              {"id": 1001, "name": "Haruhi", "gender": "F"},
+              {"id": 1002, "name": "Mikuru", "gender": "F"},
+              {"id": 1003, "name": "Yuki"  , "gender": "F"},
+              {"id": 1004, "name": "Itsuki", "gender": "M"},
+              {"id": 1005, "name": "Kyon"  , "gender": "M"},
+            ],
+          },
+        ],
+      }
+      ## assertion
+      ok {JSON(actual)} === {            # requires `JSON()` and `===`
+        "teams": [
+          {
+            "team": String,
+            "members": [
+              {"id": 1000..9999, "name": String, "gender": Set.new(["M", "F"])}
+            ].each,                     # Enumerator object (!= Array obj)
+            "leader?": String,           # key 'xxx?' means optional value
+          }
+        ].each,                          # Enumerator object (!= Array obj)
+      }
+    end
+
+  end
+end
+```
+
+
+### Complex Example
+
+* `OR(x, y, z)` matches to `x`, `y`, or `z`.
+* `AND(x, y, z)` matches to `x`, `y`, and `z`.
+* Key `"*"` matches to any key of hash object.
+* `Any()` matches to anything.
+
+<!--
+test/example43_test.rb:
+-->
+```ruby
+require 'oktest'
+require 'set'
+
+Oktest.scope do
+  topic 'JSON Example' do
+
+    spec "OR() example" do
+      ok {JSON({"val": "123"})} === {"val": OR(String, Integer)}    # OR()
+      ok {JSON({"val":  123 })} === {"val": OR(String, Integer)}    # OR()
+    end
+
+    spec "AND() example" do
+      ok {JSON({"val": "123"})} === {"val": AND(String, /^\d+$/)}   # AND()
+      ok {JSON({"val":  123 })} === {"val": AND(Integer, 1..1000)}  # AND()
+    end
+
+    spec "`*` and `ANY` example" do
+      ok {JSON({"name": "Bob", "age": 20})} === {"*": Any()}    # '*' and Any()
+    end
+
+    spec "complex exapmle" do
+      actual = {
+        "item":   "awesome item",
+        "colors": ["red", "#cceeff", "green", "#fff"],
+        "memo":   "this is awesome.",
+        "url":    "https://example.com/awesome",
+      }
+      ## assertion
+      color_names = ["red", "blue", "green", "white", "black"]
+      color_pat   = /^\#[0-9a-fA-F]{3}([0-9a-fA-F]{3})?$/
+      ok {JSON(actual)} === {
+        "colors": [
+          AND(String, OR(Set.new(color_names), color_pat)),   # AND() and OR()
+        ].each,
+        "*": Any(),             # match to any key (`"*"`) and value (`ANY`)
+      }
+    end
+
+  end
+end
+```
+
+(Note: `/^\d+$/` implies String value, and `1..100` implies Integer value.)
+
+```ruby
+## No need to write:
+##   ok {JSON{...}} === {"val": AND(String, /^\d+$/)}
+##   ok {JSON{...}} === {"val": AND(Integer, 1..100)}
+ok {JSON({"val": "A"})} === {"val": /^\d+$/}   # implies String value
+ok {JSON({"val": 99 })} === {"val": 1..100}    # implies Integer value
+```
+
+
+### Helper Methods for JSON Matcher
+
+Oktest.rb provides some helper methods and objects:
+
+* `Enum(x, y, z)` is almost same as `Set.new([x, y, z])`.
+* `Bool()` is same as `Enum(true, false)`.
+* `Length(3)` matches to length 3, and `Length(1..3)` matches to length 1..3.
+
+<!--
+test/example44_test.rb:
+-->
+```ruby
+  actual = {"gender": "M", "deleted": false, "code": "ABCD1234"}
+  ok {JSON(actual)} == {
+    "gender":  Enum("M", "F"),        # same as Set.new(["M", "F"])
+    "deleted": Bool(),                # same as Enum(true, false)
+    "code":    Length(6..10),         # code length should be 6..10
+  }
+```
+
+
 
 ## Tips
 
@@ -1597,7 +1981,7 @@ end
 If you want to use `ok {actual} == expected` style assertion in MiniTest,
 install `minitest-ok` gem instead of `otest` gem.
 
-test/example41_test.rb:
+test/example51_test.rb:
 
 ```ruby
 require 'minitest/spec'
@@ -1620,7 +2004,7 @@ See [minitest-ok README](https://github.com/kwatch/minitest-ok) for details.
 
 `rack-test_app` gem will help you to test Rack application very well.
 
-test/example42_test.rb:
+test/example52_test.rb:
 
 ```ruby
 require 'rack'
@@ -1689,11 +2073,25 @@ end
 ```
 
 
+### Environment Variale `$OKTEST_RB`
+
+You can set default command-line option to environment variale `$OKTEST_RB`.
+For examle, you can specify default reporting style with `$OKTEST_RB`.
+
+```terminal
+### change default reporting style to plain-style.
+$ export OKTEST_RB="-s plain"                  # !!!!!
+
+### run test script in plain-style reporting without '-s' option.
+$ ruby test/foo_test.rb
+```
+
+
 ### Traverser Class
 
 Oktest.rb provides `Traverser` class which implements Visitor pattern.
 
-test/example44_test.rb:
+test/example54_test.rb:
 
 ```ruby
 require 'oktest'
@@ -1750,8 +2148,8 @@ MyTraverser.new.start()
 Result:
 
 ```terminal
-$ ruby test/example44_test.rb
-# scope: test/example44_test.rb
+$ ruby test/example54_test.rb
+# scope: test/example54_test.rb
   + topic: Example Topic
     - spec: sample #1
     - spec: sample #2
@@ -1762,18 +2160,36 @@ $ ruby test/example44_test.rb
 ```
 
 
+### `--faster` Option
+
+~~If you are working in very larget project and you want to run test scripts as fast as possible, try `--faster` option of `oktest` command.~~
+
+```terminal
+$ oktest -s quiet --faster test/        ## only for very large project
+```
+
+~~Or set `Oktest::Config.ok_location = false` in your test script.~~
+
+```ruby
+require 'oktest'
+Oktest::Config.ok_location = false      ## only for very large project
+```
+
+`--faster` option is still available but no longer recommended, because performance of `ok{}` is improved significantly since Oktest.rb 1.2.0.
+
+
 ### Benchmarks
 
 Oktest.rb gem file contains benchmark script.
 It shows that Oktest.rb runs more than three times faster than RSpec.
 
 ```terminal
-$ gem install oktest        # ver 1.0.0
+$ gem install oktest        # ver 1.2.0
 $ gem install rspec         # ver 3.10.0
 $ gem install minitest      # ver 5.14.4
 $ gem install test-unit     # ver 3.4.4
 
-$ cp -pr $GEM_HOME/gems/oktest-1.0.0/benchmark .
+$ cp -pr $GEM_HOME/gems/oktest-1.2.0/benchmark .
 $ cd benchmark/
 $ rake -T
 $ ruby --version
@@ -1782,67 +2198,60 @@ ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-darwin18]
 $ rake benchmark:all
 ```
 
+Summary of example result:
+
+```
+Oktest:              6.815 real     6.511 user     0.257 sys
+Oktest (--faster):   6.401 real     6.123 user     0.240 sys
+RSpec:              32.062 real    27.778 user     4.383 sys
+MiniTest:            9.140 real     8.657 user     0.705 sys
+Test::Unit:         19.580 real    19.020 user     0.885 sys
+```
+
 Example result:
 
 ```
 ==================== oktest ====================
 oktest -sq run_all.rb
 
-## total:100000 (pass:100000, fail:0, error:0, skip:0, todo:0) in 4.86s
+## total:100000 (pass:100000, fail:0, error:0, skip:0, todo:0) in 2.36s
 
-        8.536 real        8.154 user        0.245 sys
+        6.815 real        6.511 user        0.257 sys
 
 ==================== oktest:faster ====================
 oktest -sq --faster run_all.rb
 
-## total:100000 (pass:100000, fail:0, error:0, skip:0, todo:0) in 1.64s
+## total:100000 (pass:100000, fail:0, error:0, skip:0, todo:0) in 2.01s
 
-        5.068 real        4.819 user        0.202 sys
+        6.401 real        6.123 user        0.240 sys
 
 ==================== rspec ====================
 rspec run_all.rb | tail -4
 
-Finished in 14.44 seconds (files took 15.81 seconds to load)
+Finished in 15.27 seconds (files took 16.08 seconds to load)
 100000 examples, 0 failures
 
 
-        30.798 real        26.565 user        4.392 sys
+        32.062 real        27.778 user        4.383 sys
 
 ==================== minitest ====================
 ruby run_all.rb | tail -4
 
-Finished in 5.190405s, 19266.3193 runs/s, 19266.3193 assertions/s.
+Finished in 5.281425s, 18934.2838 runs/s, 37868.5677 assertions/s.
 
-100000 runs, 100000 assertions, 0 failures, 0 errors, 0 skips
+100000 runs, 200000 assertions, 0 failures, 0 errors, 0 skips
 
-        8.767 real        8.157 user        0.761 sys
+        9.140 real        8.657 user        0.705 sys
 
 ==================== testunit ====================
 ruby run_all.rb | tail -5
 -------------------------------------------------------------------------------
-100000 tests, 100000 assertions, 0 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
+100000 tests, 200000 assertions, 0 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
 100% passed
 -------------------------------------------------------------------------------
-8957.19 tests/s, 8957.19 assertions/s
-
-        17.838 real        17.201 user        0.879 sys
-```
+7775.59 tests/s, 15551.18 assertions/s
 
-
-### `--faster` Option
-
-If you are working in very larget project and you want to run test scripts
-as fast as possible, try `--faster` option of `oktest` command.
-
-```terminal
-$ oktest -s quiet --faster test/        ## only for very large project
-```
-
-Or set `Oktest::Config.ok_location = false` in your test script.
-
-```ruby
-require 'oktest'
-Oktest::Config.ok_location = false      ## only for very large project
+        19.580 real        19.020 user        0.885 sys
 ```