rgot 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edabddcdf99d28070fbe94f391d49d7c034cb1b6d467629c76fc671f7d27956b
-  data.tar.gz: 642606670788ef496178d91b9450f6c08bb97e8e4f9e14442e0868ddf0c2acbd
+  metadata.gz: e2f0075689755b0a44db0674a5069769d1ee4c2567774d7bb7422ba5b27c8960
+  data.tar.gz: 9ddd64091ca0daeff256fcc5c305aad378a92472f4522b875512fb35915d74aa
 SHA512:
-  metadata.gz: eb8824c1730be5395ffb22b3c075239b612a987db000367c804201394305b080834bb246c7c198da556e26090ae7a8424830b6253f7c10fd0183662ff6d490d0
-  data.tar.gz: 4064bdb31930c1cc0a072ab6c7113f93f66ce8cd3bafd4208824c36a5c591685a0e82f7e09758ff32a4d342eefee64efeb92910e8b45c75a48175571f84e03f7
+  metadata.gz: 2e24662ccc2f6f4644eec95f9764975b86d2ea40f49c3c8ae569f428809ca08df79e6517d2bbcf0ec7d08e610867972133a1a9ab5df245cf36896afb8ace7e63
+  data.tar.gz: ac5c041deb124812d911d0af697a06a398ced2c79bc54f6058ec4cb2499af9dd814007f3e0c8951c50448892ba0fbc0a6846dfd879c3497601b4aebf5d00116e

data/.github/workflows/main.yml

@@ -14,13 +14,13 @@ jobs:
     strategy:
       matrix:
         ruby:
-          - '2.6.10'
-          - '2.7.6'
-          - '3.0.4'
-          - '3.1.2'
+          - '2.7.7'
+          - '3.0.5'
+          - '3.1.3'
+          - '3.2.0'
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:

data/.gitignore

@@ -1,3 +1,3 @@
-Gemfile.lock
 pkg
 tmp
+/.gem_rbs_collection

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem "rbs"
+gem "steep"
+gem "debug"

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    rgot (1.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    concurrent-ruby (1.1.10)
+    csv (3.2.6)
+    debug (1.7.1)
+    ffi (1.15.5)
+    fileutils (1.7.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.2)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.5.3)
+    minitest (5.17.0)
+    parallel (1.22.1)
+    parser (3.2.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rbs (2.8.2)
+    securerandom (0.2.2)
+    steep (1.3.0)
+      activesupport (>= 5.1)
+      csv (>= 3.0.9)
+      fileutils (>= 1.1.0)
+      json (>= 2.1.0)
+      language_server-protocol (>= 3.15, < 4.0)
+      listen (~> 3.0)
+      logger (>= 1.3.0)
+      parallel (>= 1.0.0)
+      parser (>= 3.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rbs (>= 2.8.0)
+      securerandom (>= 0.1)
+      strscan (>= 1.0.0)
+      terminal-table (>= 2, < 4)
+    strscan (3.0.5)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  debug
+  rake
+  rbs
+  rgot!
+  steep
+
+BUNDLED WITH
+   2.4.2

data/README.md

@@ -93,6 +93,33 @@ ok	FooTest	2.782s
 
 `b.n` is automatically adjusted.
 
+## Fuzzing
+
+```
+$ rgot target_file_test.rb --fuzz . --fuzztime 1
+```
+
+Fuzzing tests are also supported.
+Please refer to the gloang documentation for details.
+
+https://go.dev/security/fuzz/
+
+```ruby
+module FooTest
+  # To enable fuzzing, the method name
+  # should be prefixed with `fuzz`.
+  def fuzz_any_func(f)
+    f.add(5, "hello")
+    f.fuzz do |t, i, s|
+      out, err = foo(i, s)
+      if err != nil && out != ""
+        t.errorf("%s, %s", out, err)
+      end
+    end
+  end
+end
+```
+
 ## Example
 
 Rgot's example feature is the best and if you want to write the sample code of your library.
@@ -189,6 +216,8 @@ Method name should be set `test_*` for testing.
 
 And benchmark method should be set `benchmark_*`.
 
+And fuzz method should be set `fuzz_*`.
+
 And example method should be set `example_*`.
 
 ```ruby
@@ -199,6 +228,9 @@ module XxxTest
   def benchmark_any_name(b)
   end
 
+  def fuzz_any_name(f)
+  end
+
   def example_any_name
   end
 end
@@ -218,6 +250,8 @@ Usage: rgot [options]
         --thread [count,...]         set thread counts of comma split
         --require [path]             load some code before running
         --load-path [path]           Specify $LOAD_PATH directory
+        --fuzz [regexp]              run the fuzz test matching `regexp`
+        --fuzztime [sec]             time to spend fuzzing; default is to run indefinitely
 ```
 
 ## Basic
@@ -341,7 +375,7 @@ And this is default virtual main code.
 ```ruby
 module TestSomeCode
   def test_main(m)
-    exit m.run
+    m.run
   end
 end
 ```
@@ -362,7 +396,7 @@ module TestSomeCode
     the_before_running_some_code
     code = m.run
     the_after_running_some_code
-    exit code
+    code
   end
 end
 ```
@@ -515,3 +549,39 @@ def benchmark_foo(b)
   end
 end
 ```
+
+## Rgot::F (Fuzzing)
+
+### Rgot::F#add
+
+Set the sample value with `#add`. This value is also used as a test. It guesses the type from the value and generates a random value.
+
+### Rgot::F#fuzz
+
+Generate the random value generated by `#fuzz` and execute the code.
+The `t` becomes an instance of `Rgot::T` and the test can be run as usual.
+
+```ruby
+def fuzz_foo(f)
+  f.add(100, "hello")
+  f.fuzz do |t, i, s|
+    i #=> 100, 84, 17, 9, 66, ...
+    s #=> "hello", "Y\xD5\xAB\xBA\x8E", "r\x95D\xA5\xF7", "\xCEj=\x9C\xBD", ...
+    if !foo(i, s)
+      t.error("fail with i=#{i}, s=#{s}")
+    end
+  end
+end
+```
+
+# TODO
+
+- [ ] Support to save and load fuzzing data
+
+## v2
+
+- [ ] Support sub testing
+- [ ] Fix duration argument unit
+- [ ] Refactoring
+  - [ ] Fix M#initialize argument
+  - [ ] Fix internal class API

data/Rakefile

@@ -5,6 +5,9 @@ task :test do |t|
   targets = [
     "test/rgot_common_test.rb",
     "test/rgot_test.rb",
+    "test/rgot_benchmark_test.rb",
+    "test/rgot_example_test.rb",
+    "test/rgot_fuzzing_test.rb",
   ]
   ruby "bin/rgot -v #{targets.join(' ')}"
 end

data/Steepfile

@@ -0,0 +1,4 @@
+target :lib do
+  check "lib"
+  signature "sig"
+end

data/bin/rgot

@@ -1,4 +1,4 @@
 #! /usr/bin/env ruby
 require 'rgot/cli'
 
-Rgot::Cli.new(ARGV).run
+exit Rgot::Cli.new(ARGV).run

data/lib/rgot/b.rb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 module Rgot
   class B < Common
-    Options = Struct.new(
+    Options = _ = Struct.new(
       :procs,
       :threads,
       :benchtime,
     )
 
+    # @dynamic n, n=
     attr_accessor :n
+
     def initialize(benchmark_module, name, opts = Options.new)
       super()
       @n = 1
@@ -14,7 +18,7 @@ module Rgot
       @name = name
       @opts = opts
       @timer_on = false
-      @duration = 0
+      @duration = 0.0
       @module.extend @module if @module
     end
 
@@ -36,34 +40,34 @@ module Rgot
       if @timer_on
         @start = Rgot.now
       end
-      @duration = 0
+      @duration = 0.0
     end
 
     def run(&block)
       n = 1
       benchtime = (@opts.benchtime || 1).to_f
       catch(:skip) do
-        run_n(n.to_i, block)
-        while !failed? && @duration < benchtime && @n < 1e9
+        run_n(n, block)
+        while !failed? && @duration < benchtime && n < 1e9
           if @duration < (benchtime / 100.0)
-            @n *= 100
+            n *= 100
           elsif @duration < (benchtime / 10.0)
-            @n *= 10
+            n *= 10
           elsif @duration < (benchtime / 5.0)
-            @n *= 5
+            n *= 5
           elsif @duration < (benchtime / 2.0)
-            @n *= 2
+            n *= 2
           else
-            if @n.to_i == 1
+            if n == 1
               break
             end
-            @n *= 1.2
+            n = [(n * 1.2).to_i, n + 1].max || raise
           end
-          run_n(@n.to_i, block)
+          run_n(n, block)
         end
       end
 
-      BenchmarkResult.new(n: @n, t: @duration)
+      BenchmarkResult.new(n: n, t: @duration)
     end
 
     def run_parallel
@@ -81,7 +85,6 @@ module Rgot
           }.each(&:join)
         end
       end
-      @n *= procs * threads
       Process.waitall
     end
 

data/lib/rgot/benchmark_result.rb

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
 module Rgot
   class BenchmarkResult
+    # @dynamic n, t
+    attr_reader :n
+    attr_reader :t
+
     def initialize(n:, t:)
       @n = n
       @t = t

data/lib/rgot/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 require_relative '../rgot'
@@ -11,7 +13,7 @@ module Rgot
     def run
       opts = Rgot::M::Options.new
       parse_option(opts)
-      process_start(opts)
+      main_process(opts)
     end
 
     private
@@ -50,6 +52,15 @@ module Rgot
         o.on '--load-path [path]', "Specify $LOAD_PATH directory" do |arg|
           $LOAD_PATH.unshift(arg)
         end
+        o.on '--fuzz [regexp]', "run the fuzz test matching `regexp`" do |arg|
+          unless arg
+            raise Rgot::OptionError, "missing argument for flag --fuzz"
+          end
+          opts.fuzz = arg
+        end
+        o.on '--fuzztime [sec]', "time to spend fuzzing; default is to run indefinitely" do |arg|
+          opts.fuzztime = arg
+        end
       end
       parser.parse!(@argv)
 
@@ -74,81 +85,97 @@ module Rgot
       end
     end
 
-    def process_start(opts)
+    def main_process(opts)
       code = 0
-      testing_files.map do |testing_file|
-        begin
-          pid = fork do
-            require testing_file
-
-            modules = Object.constants.select { |c|
-              next if c == :FileTest
-              /.*Test\z/ =~ c
-            }.map { |c|
-              Object.const_get(c)
-            }
-
-            modules.each do |test_module|
-              tests = []
-              benchmarks = []
-              examples = []
-              main = nil
-              methods = test_module.instance_methods
-              methods.grep(/\Atest_/).each do |m|
-                if m == :test_main && main.nil?
-                  main = Rgot::InternalTest.new(test_module, m)
-                else
-                  tests << Rgot::InternalTest.new(test_module, m)
-                end
-              end
-
-              methods.grep(/\Abenchmark_/).each do |m|
-                benchmarks << Rgot::InternalBenchmark.new(test_module, m)
-              end
-
-              methods.grep(/\Aexample_?/).each do |m|
-                examples << Rgot::InternalExample.new(test_module, m)
-              end
-
-              duration = Rgot.now
-              at_exit do
-                template = "%s\t%s\t%.3fs"
-
-                case $!
-                when SystemExit
-                  if $!.success?
-                    # exit 0
-                    puts sprintf(template, "ok  ", test_module, Rgot.now - duration)
-                  else
-                    # exit 1
-                    puts "exit status #{$!.status}"
-                    puts sprintf(template, "FAIL", test_module, Rgot.now - duration)
-                  end
-                when NilClass
-                  # not raise, not exit
-                else
-                  # any exception
-                  puts sprintf(template, "FAIL", test_module, Rgot.now - duration)
-                end
-              end
-              m = Rgot::M.new(tests: tests, benchmarks: benchmarks, examples: examples, opts: opts)
-              if main
-                main.module.extend main.module
-                main.module.instance_method(main.name).bind(main.module).call(m)
-              else
-                exit m.run
-              end
-            end
-          end
-        ensure
-          _, status = Process.waitpid2(pid)
-          unless status.success?
-            code = 1
-          end
+
+      testing_files.each do |testing_file|
+        result = child_process(opts, testing_file)
+        unless result == 0
+          code = 1
+        end
+      end
+
+      code
+    end
+
+    def child_process(opts, testing_file)
+      node = RubyVM::AbstractSyntaxTree.parse_file(testing_file).children[2]
+      test_module_name = find_toplevel_name(node)
+
+      if opts.fuzz
+        # fuzzing observes changes in coverage.
+        require 'coverage'
+        Coverage.start(oneshot_lines: true)
+      end
+      load testing_file
+
+      test_module = Object.const_get(test_module_name)
+      tests = []
+      benchmarks = []
+      examples = []
+      fuzz_targets = []
+      main = nil
+      methods = test_module.public_instance_methods
+      methods.grep(/\Atest_/).each do |m|
+        if m == :test_main && main.nil?
+          main = Rgot::InternalTest.new(test_module, m)
+        else
+          tests << Rgot::InternalTest.new(test_module, m)
         end
       end
 
-      exit code
+      methods.grep(/\Abenchmark_/).each do |m|
+        benchmarks << Rgot::InternalBenchmark.new(test_module, m)
+      end
+
+      methods.grep(/\Aexample_?/).each do |m|
+        examples << Rgot::InternalExample.new(test_module, m)
+      end
+
+      methods.grep(/\Afuzz_/).each do |m|
+        fuzz_targets << Rgot::InternalFuzzTarget.new(test_module, m)
+      end
+
+      m = Rgot::M.new(
+        test_module: test_module,
+        tests: tests,
+        benchmarks: benchmarks,
+        examples: examples,
+        fuzz_targets: fuzz_targets,
+        opts: opts
+      )
+      if main
+        main.module.extend main.module
+        main.module.instance_method(:test_main).bind(main.module).call(m)
+      else
+        m.run
+      end
+    end
+
+    def find_toplevel_name(node)
+      case node.type
+      when :MODULE
+        find_toplevel_name(node.children.first)
+      when :CONST, :COLON3
+        node.children.first
+      when :COLON2
+        case node.children
+        in [nil, sym]
+          # module Foo
+          sym
+        in [namespace, sym]
+          # module Foo::Bar
+          find_toplevel_name(namespace)
+        end
+      when :BLOCK
+        module_node = node.children.find { |c| c.type == :MODULE }
+        unless module_node
+          raise "no module found"
+        end
+        find_toplevel_name(module_node)
+      else
+        raise node.type.to_s
+      end
     end
   end
 end

data/lib/rgot/common.rb

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 require 'thread'
 require 'pathname'
 
 module Rgot
   class Common
+    # @dynamic output, output=
     attr_accessor :output
 
     def initialize
-      @output = ""
+      @output = "".dup
       @failed = false
       @skipped = false
       @finished = false
       @start = Rgot.now
-      @mutex = Mutex.new
+      @mutex = Thread::Mutex.new
     end
 
     def failed?
@@ -98,9 +101,10 @@ module Rgot
       # internal_log -> synchronize -> internal_log -> other log -> running method
       c = caller[4]
       path = c.sub(/:.*/, '')
-      line = c.match(/:(\d+?):/)[1]
+      line = c.match(/:(\d+?):/)&.[](1)
       relative_path = Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
-      "\t#{relative_path}:#{line}: #{str}\n"
+      # Every line is indented at least 4 spaces.
+      "    #{relative_path}:#{line}: #{str}\n"
     end
 
     def internal_log(msg)

data/lib/rgot/example_parser.rb

@@ -1,14 +1,19 @@
+# frozen_string_literal: true
+
 require 'ripper'
 
 module Rgot
   class ExampleParser < Ripper
+
+    # @dynamic examples, examples=
     attr_accessor :examples
+
     def initialize(code)
       super
       @examples = []
       @in_def = false
       @has_output = false
-      @output = ""
+      @output = "".dup
     end
 
     def on_def(method, args, body)