viiite 0.1.0 → 0.2.0

data/spec/integration/report/viiite_report_9.cmd

@@ -0,0 +1 @@
+viiite report --regroup=ruby,size,bench --hierarchy Array/bench_sort

data/spec/integration/report/viiite_report_9.stdout

@@ -0,0 +1,88 @@
++-------------------+---------------------------------------------------------------------------+
+| :ruby             | :measure                                                                  |
++-------------------+---------------------------------------------------------------------------+
+| jruby 1.6.3       | +-------+---------------------------------------------------------------+ |
+|                   | | :size | :measure                                                      | |
+|                   | +-------+---------------------------------------------------------------+ |
+|                   | |   100 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.002000 | 0.000000 | 0.002000 | 0.002000 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |  1000 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.019000 | 0.000000 | 0.019000 | 0.020000 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | +-------+---------------------------------------------------------------+ |
+| rubinius 1.2.5dev | +-------+---------------------------------------------------------------+ |
+|                   | | :size | :measure                                                      | |
+|                   | +-------+---------------------------------------------------------------+ |
+|                   | |   100 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.000399 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |  1000 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.028002 | 0.000000 | 0.028002 | 0.042525 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | +-------+---------------------------------------------------------------+ |
+| rubinius 2.0.0dev | +-------+---------------------------------------------------------------+ |
+|                   | | :size | :measure                                                      | |
+|                   | +-------+---------------------------------------------------------------+ |
+|                   | |   100 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.000385 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |  1000 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.004000 | 0.000000 | 0.004000 | 0.005118 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | +-------+---------------------------------------------------------------+ |
+| ruby 1.8.7        | +-------+---------------------------------------------------------------+ |
+|                   | | :size | :measure                                                      | |
+|                   | +-------+---------------------------------------------------------------+ |
+|                   | |   100 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.000082 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |  1000 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.001091 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | +-------+---------------------------------------------------------------+ |
+| ruby 1.9.2p290    | +-------+---------------------------------------------------------------+ |
+|                   | | :size | :measure                                                      | |
+|                   | +-------+---------------------------------------------------------------+ |
+|                   | |   100 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.000080 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |  1000 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.001121 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | +-------+---------------------------------------------------------------+ |
+| ruby 1.9.3dev     | +-------+---------------------------------------------------------------+ |
+|                   | | :size | :measure                                                      | |
+|                   | +-------+---------------------------------------------------------------+ |
+|                   | |   100 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.000084 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |  1000 | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :bench        | :user    | :system  | :total   | :real    | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | |       | | :"Array#sort" | 0.000000 | 0.000000 | 0.000000 | 0.001163 | | |
+|                   | |       | +---------------+----------+----------+----------+----------+ | |
+|                   | +-------+---------------------------------------------------------------+ |
++-------------------+---------------------------------------------------------------------------+

data/spec/integration/test_command.rb

@@ -1,33 +1,29 @@
 require 'spec_helper'
-describe "viiite command / " do
+describe "viiite commands" do
 
   Dir[File.expand_path('../**/*.cmd', __FILE__)].each do |input|
-    cmd = File.readlines(input).first
-    specify{ cmd.should =~ /^viiite / }
-  
-    describe "#{File.basename(input)}: #{cmd}" do
-      let(:argv)     { Quickl.parse_commandline_args(cmd)[1..-1] }
-      let(:stdout)   { File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stdout") }
-      let(:stderr)   { File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stderr") }
-      let(:stdout_expected) { File.exists?(stdout) ? File.read(stdout) : "" }
-      let(:stderr_expected) { File.exists?(stderr) ? File.read(stderr) : "" }
+    cmd = File.read(input).chomp
 
-      before{ redirect_io }
-      after { restore_io  }
-      
-      specify{
+    specify "#{File.basename(input)}: #{cmd}" do
+      argv = Quickl.parse_commandline_args(cmd)[1..-1]
+      stdout = File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stdout")
+      stderr = File.join(File.dirname(input), "#{File.basename(input, ".cmd")}.stderr")
+      stdout_expected = File.exists?(stdout) ? File.read(stdout) : ""
+      stderr_expected = File.exists?(stderr) ? File.read(stderr) : ""
+
+      cmd.should match /^viiite /
+      cache = File.join(fixtures_folder, "saved")
+      out, err = capture_io do
         begin
-          if i = argv.index("raw_data")
-            argv[i] = File.expand_path('../raw_data.rash', __FILE__)
-          end
-          Viiite::Command.run(argv)
+          Viiite::Command.run(["--suite=#{fixtures_folder}/bdb", "--cache=#{cache}"] + argv)
         rescue SystemExit
-          $stdout << "SystemExit" << "\n"
+          puts "SystemExit"
         end
-        $stdout.string.should(eq(stdout_expected)) unless RUBY_VERSION < "1.9"
-        $stderr.string.should(eq(stderr_expected)) unless RUBY_VERSION < "1.9"
-      }
+      end
+
+      out.should eq stdout_expected unless RUBY_VERSION < "1.9"
+      err.should eq stderr_expected unless RUBY_VERSION < "1.9"
     end
   end
-    
+
 end

data/spec/integration/viiite/viiite_help.stdout

@@ -7,6 +7,12 @@ SYNOPSIS
 OPTIONS
   -Idirectory                      specify $LOAD_PATH directory (may be used more than once)
   -rlibrary                        require the library, before executing viiite
+      --suite=FOLDER               Specify the folder of the benchmark suite (defaults to 'benchmarks')
+      --pattern=GLOB               Specify the pattern to find benchmarks in the suite folder (defaults to '**/*.rb')
+      --[no-]cache=[FOLDER]        Specify the cache heuristic and folder (defaults to --cache)
+      --cache-mode=MODE            Specify the exact mode for accessing cache files
+  -a, --append                     Shortcut to --cache-mode=a
+  -w, --write                      Shortcut to --cache-mode=w
       --help                       Show help
       --version                    Show version
 

data/spec/spec_helper.rb

@@ -1,23 +1,17 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'viiite'
+require 'stringio'
 
-def redirect_io
-  $oldstdout = $stdout 
-  $oldstderr = $stderr
-  $stdout = StringIO.new
-  $stderr = StringIO.new
-  [$stdout, $stderr]
+def capture_io
+  stdout, stderr = $stdout, $stderr
+  out, err = StringIO.new, StringIO.new
+  $stdout, $stderr = out, err
+  yield
+  [out.string, err.string]
+ensure
+  $stdout, $stderr = stdout, stderr
 end
 
-def restore_io
-  $stdout = $oldstdout
-  $stderr = $oldstderr
-  $oldstdout = nil 
-  $oldstderr = nil 
+def fixtures_folder
+  File.expand_path('../fixtures', __FILE__)
 end
-
-def bench_iteration
-  File.expand_path('../fixtures/bench_iteration.rb', __FILE__)
-end
-
-

data/spec/unit/bdb/cached/test_dataset.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Viiite
+  class BDB
+    describe Cached, "#dataset" do
+
+      let(:folder) { File.join(fixtures_folder, '.cache') }
+      let(:bdb)    { Cached.new(delegate, folder)         }
+      subject      { bdb.dataset(name)                    }
+      before(:each){ FileUtils.rm_rf(folder)              }
+
+      describe "when the benchmark exists" do
+        let(:delegate){
+          @delegate ||= Object.new.extend Module.new{
+            attr_reader :called
+            def benchmark(name)
+              @called = true
+              Alf::Relation[{:name => name}]
+            end
+            alias :dataset :benchmark
+          }
+        }
+        let(:name)  { "Array/bench_sort"                            }
+        let(:cached){ File.join(folder, "Array", "bench_sort.rash") }
+        after{
+          File.exists?(cached).should be_true
+          FileUtils.rm_rf(cached)
+        }
+
+        describe 'when the cache file does not exist yet' do
+          before{
+            File.exists?(cached).should be_false
+          }
+          specify{
+            subject.to_a.should eq([{:name => 'Array/bench_sort'}])
+            delegate.called.should be_true
+          }
+        end
+
+        describe 'when the cache file already exists' do
+          before{
+            FileUtils.mkdir_p(File.dirname(cached))
+            File.open(cached, "w") do |io|
+              io << "{:name => 'Array/bench_sort'}"
+            end
+          }
+          specify{
+            subject.to_a.should eq([{:name => 'Array/bench_sort'}])
+            delegate.called.should be_false
+          }
+        end
+
+      end
+
+      describe "when the benchmark does not exist" do
+        let(:delegate){
+          Object.new.extend Module.new{
+            def benchmark(name); raise Alf::NoSuchDatasetError; end
+            alias :dataset :benchmark
+          }
+        }
+        let(:name){ "NotA/Class/bench_non_existing" }
+        specify{ lambda{subject}.should raise_error(Alf::NoSuchDatasetError) }
+      end
+
+    end
+  end
+end

data/spec/unit/bdb/immediate/test_benchmark.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Viiite
+  class BDB
+    describe Immediate, "#benchmark" do
+
+      let(:bdb){ Immediate.new(fixtures_folder+'/bdb') }
+      subject{ bdb.benchmark(name) }
+
+      describe "when the file exists in root folder (String)" do
+        let(:name){ "bench_iteration" }
+        it{ should be_a(Viiite::Benchmark) }
+      end
+
+      describe "when the file exists in root folder (Symbol)" do
+        let(:name){ :bench_iteration }
+        it{ should be_a(Viiite::Benchmark) }
+      end
+
+      describe "when the file exists in a sub folder (String)" do
+        let(:name){ "Array/bench_sort" }
+        it{ should be_a(Viiite::Benchmark) }
+      end
+
+      describe "when the file does not exist" do
+        let(:name){ "NotA/Class/bench_non_existing" }
+        specify{ lambda{subject}.should raise_error(NoSuchBenchmarkError) }
+      end
+
+    end
+  end
+end

data/spec/unit/bdb/immediate/test_dataset.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Viiite
+  class BDB
+    describe Immediate, "#dataset" do
+
+      let(:bdb){ Immediate.new(fixtures_folder+'/bdb') }
+      subject{ bdb.dataset(name) }
+
+      describe "when the file exists in root folder (String)" do
+        let(:name){ "bench_iteration" }
+        it{ should be_a(Viiite::Benchmark) }
+      end
+
+      describe "when the file exists in root folder (Symbol)" do
+        let(:name){ :bench_iteration }
+        it{ should be_a(Viiite::Benchmark) }
+      end
+
+      describe "when the file exists in a sub folder (String)" do
+        let(:name){ "Array/bench_sort" }
+        it{ should be_a(Viiite::Benchmark) }
+      end
+
+      describe "when the file does not exist" do
+        let(:name){ "NotA/Class/bench_non_existing" }
+        specify{ lambda{subject}.should raise_error(::Alf::NoSuchDatasetError) }
+      end
+
+    end
+  end
+end

data/spec/unit/bdb/immediate/test_enumerable.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Viiite
+  class BDB
+    describe Immediate, "enumerable" do
+
+      let(:bdb){ Immediate.new(fixtures_folder+'/bdb') }
+
+      specify{
+        bdb.all?{|tuple|
+          File.exists?(tuple[:file])
+        }.should be_true
+        bdb.to_rel.project([:name]).should eq(Alf::Relation[
+          {:name => "bench_iteration"},
+          {:name => "Array/bench_sort"}
+        ])
+      }
+
+    end
+  end
+end

data/spec/unit/bdb/immediate/test_pattern.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Viiite
+  class BDB
+    describe Immediate, "pattern" do
+
+      let(:bdb){ Immediate.new(fixtures_folder+'/bdb', '*_iteration.rb') }
+
+      specify{
+        bdb.all?{|tuple|
+          File.exists?(tuple[:file])
+        }.should be_true
+        bdb.to_rel.project([:name]).should eq(Alf::Relation[
+          {:name => "bench_iteration"}
+        ])
+      }
+
+      specify{
+        lambda {
+          Immediate.new(fixtures_folder+'/bdb', 'invalid.{a,b}')
+        }.should raise_error(InvalidPattern)
+      }
+
+    end
+  end
+end

data/spec/unit/bdb/test_new.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Viiite
+  describe BDB, ".new" do
+
+    subject{ BDB.new(options) }
+
+    describe "with default options" do
+      let(:options){ {} }
+      specify{
+        subject.should be_cached
+        subject.folder.should eq("benchmarks")
+        subject.cache_folder.should eq("benchmarks/.cache")
+        subject.cache_mode.should eq("w")
+      }
+    end
+
+    describe "with a specific folder" do
+      let(:options){ {:folder => "/tmp"} }
+      specify{
+        subject.should be_cached
+        subject.folder.should eq("/tmp")
+        subject.cache_folder.should eq("/tmp/.cache")
+      }
+    end
+
+    describe "with cache set to false" do
+      let(:options){ {:cache => false} }
+      specify{
+        subject.folder.should eq("benchmarks")
+        subject.should_not be_cached
+      }
+    end
+
+    describe "with cache set to a specific folder" do
+      let(:options){ {:cache => "/tmp"} }
+      specify{
+        subject.should be_cached
+        subject.folder.should eq("benchmarks")
+        subject.cache_folder.should eq("/tmp")
+      }
+    end
+
+  end
+end

data/spec/unit/bdb/utils/test_bench_file.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Viiite
+  class BDB
+    describe Utils, "#bench_file" do
+
+      let(:utils) { Object.new.extend(Utils) }
+      let(:folder){ fixtures_folder }
+      subject{ utils.bench_file(folder, file, ext) }
+
+      describe "on a file in root folder" do
+        let(:file){ "bench_iteration" }
+        let(:ext) { ".rb" }
+        it{ should eq(File.join(folder, "bench_iteration.rb")) }
+      end
+
+      describe "on a file in a sub folder" do
+        let(:file){ "Array/bench_sort" }
+        let(:ext) { ".rb" }
+        it{ should eq(File.join(folder, "Array", "bench_sort.rb")) }
+      end
+
+    end
+  end
+end