minilab 1.1.0-x86-mswin32-60

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/typedef_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Custom type definitions" do
+  it "attach_function with custom typedef" do
+    module CustomTypedef
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      typedef :uint, :fubar_t
+      attach_function :ret_u32, [ :fubar_t ], :fubar_t
+    end
+    CustomTypedef.ret_u32(0x12345678).should == 0x12345678
+  end
+  it "variadic invoker with custom typedef" do
+    module VariadicCustomTypedef
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      typedef :uint, :fubar_t
+      attach_function :pack_varargs, [ :buffer_out, :string, :varargs ], :void
+    end
+    buf = FFI::Buffer.new :uint, 10
+    VariadicCustomTypedef.pack_varargs(buf, "i", :fubar_t, 0x12345678)
+    buf.get_int64(0).should == 0x12345678
+  end
+  it "Callback with custom typedef parameter" do
+    module CallbackCustomTypedef
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      typedef :uint, :fubar3_t
+      callback :cbIrV, [ :fubar3_t ], :void
+      attach_function :testCallbackU32rV, :testClosureIrV, [ :cbIrV, :fubar3_t ], :void
+    end
+    i = 0
+    CallbackCustomTypedef.testCallbackU32rV(0xdeadbeef) { |v| i = v }
+    i.should == 0xdeadbeef
+  end
+    module StructCustomTypedef
+      extend FFI::Library
+      ffi_lib TestLibrary::PATH
+      typedef :uint, :fubar3_t
+      class S < FFI::Struct
+        layout :a, :fubar3_t
+      end
+    end
+  it "Struct with custom typedef field" do
+    s = StructCustomTypedef::S.new
+    s[:a] = 0x12345678
+    s.pointer.get_uint(0).should == 0x12345678
+  end
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/union_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+module LibTest
+  Types = {
+    's8' => [:char, :c, 1],
+    's16' => [:short, :s, 0xff0], 
+    's32' => [:int, :i, 0xff00],
+    's64' => [:long_long, :j, 0xffff00],
+    'long' => [:long, :l, 0xffff],
+    'f32' => [:float, :f, 1.0001],
+    'f64' => [:double, :d, 1.000000001]
+  }
+  class TestUnion < FFI::Union
+    layout( :a, [:char, 10], 
+            :i, :int, 
+            :f, :float,
+            :d, :double,
+            :s, :short,
+            :l, :long,
+            :j, :long_long,
+            :c, :char )
+  end
+  Types.keys.each do |k| 
+    attach_function "union_align_#{k}", [ :pointer ], Types[k][0]
+    attach_function "union_make_union_with_#{k}", [ Types[k][0] ], :pointer
+  end
+  attach_function :union_size, [], :uint
+end
+
+describe 'Union' do
+  before do
+    @u = LibTest::TestUnion.new
+  end
+  it 'should place all the fields at offset 0' do
+    LibTest::TestUnion.members.all? { |m| LibTest::TestUnion.offset_of(m) == 0 }.should be_true
+  end
+  LibTest::Types.each do |k, type|
+    it "should correctly align/write a #{type[0]} value" do
+      @u[type[1]] = type[2]
+      if k == 'f32' or k == 'f64'
+        (@u[type[1]] - LibTest.send("union_align_#{k}", @u.to_ptr)).abs.should < 0.00001
+      else
+        @u[type[1]].should == LibTest.send("union_align_#{k}", @u.to_ptr)
+      end
+    end
+  end
+  LibTest::Types.each do |k, type|
+    it "should read a #{type[0]} value from memory" do
+      @u = LibTest::TestUnion.new(LibTest.send("union_make_union_with_#{k}", type[2]))
+      if k == 'f32' or k == 'f64'
+        (@u[type[1]] - type[2]).abs.should < 0.00001
+      else
+        @u[type[1]].should == type[2]
+      end
+    end
+  end
+  it 'should return a size equals to the size of the biggest field' do
+    LibTest::TestUnion.size.should == LibTest.union_size
+  end
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/ffi/variadic_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+describe "Function with variadic arguments" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    attach_function :pack_varargs, [ :buffer_out, :string, :varargs ], :void
+  end
+  [ 0, 127, -128, -1 ].each do |i|
+    it "call variadic with (:char (#{i})) argument" do
+      buf = FFI::Buffer.new :long_long
+      LibTest.pack_varargs(buf, "c", :char, i)
+      buf.get_int64(0).should == i
+    end
+  end
+  [ 0, 0x7f, 0x80, 0xff ].each do |i|
+    it "call variadic with (:uchar (#{i})) argument" do
+      buf = FFI::Buffer.new :long_long
+      LibTest.pack_varargs(buf, "C", :uchar, i)
+      buf.get_int64(0).should == i
+    end
+  end
+  [ 0, 1.234567, 9.87654321 ].each do |v|
+    it "call variadic with (:float (#{v})) argument" do
+      buf = FFI::Buffer.new :long_long
+      LibTest.pack_varargs(buf, "f", :float, v.to_f)
+      buf.get_float64(0).should == v
+    end
+  end
+  [ 0, 1.234567, 9.87654321 ].each do |v|
+    it "call variadic with (:double (#{v})) argument" do
+      buf = FFI::Buffer.new :long_long
+      LibTest.pack_varargs(buf, "f", :double, v.to_f)
+      buf.get_float64(0).should == v
+    end
+  end
+  module Varargs
+    PACK_VALUES = {
+      'c' => [ 0x12  ],
+      'C' => [ 0x34  ],
+      's' => [ 0x5678 ],
+      'S' => [ 0x9abc ],
+      'i' => [ 0x7654321f ],
+      'I' => [ 0xfee1babe ],
+      'l' => [ 0x1f2e3d4c ],
+      'L' => [ 0xf7e8d9ca ],
+      'j' => [ 0x1eafdeadbeefa1b2 ],
+      'f' => [ 1.23456789 ],
+      'd' => [ 9.87654321 ]
+    }
+    TYPE_MAP = {
+      'c' => :char, 'C' => :uchar, 's' => :short, 'S' => :ushort,
+      'i' => :int, 'I' => :uint, 'j' => :long_long, 'J' => :ulong_long,
+      'l' => :long, 'L' => :ulong, 'f' => :float, 'd' => :double
+    }
+    def self.verify(p, off, v)
+      if v.kind_of?(Float)
+        p.get_float64(off).should == v
+      else
+        p.get_int64(off).should == v
+      end
+    end
+  end
+  Varargs::PACK_VALUES.keys.each do |t1|
+    Varargs::PACK_VALUES.keys.each do |t2|
+      Varargs::PACK_VALUES.keys.each do |t3|
+        Varargs::PACK_VALUES[t1].each do |v1|
+          Varargs::PACK_VALUES[t2].each do |v2|
+            Varargs::PACK_VALUES[t3].each do |v3|
+              fmt = "#{t1}#{t2}#{t3}"
+              params = [ Varargs::TYPE_MAP[t1], v1, Varargs::TYPE_MAP[t2], v2, Varargs::TYPE_MAP[t3], v3 ]
+              it "call(#{fmt}, #{params.join(',')})" do
+                buf = FFI::Buffer.new :long_long, 3
+                LibTest.pack_varargs(buf, fmt, *params)
+                Varargs.verify(buf, 0, v1)
+                Varargs.verify(buf, 8, v2)
+                Varargs.verify(buf, 16, v3)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/ffi-0.4.0-x86-mswin32/spec/spec.opts

@@ -0,0 +1,4 @@
+--color
+--format
+specdoc
+

data/vendor/hardmock-1.3.7/CHANGES

@@ -0,0 +1,78 @@
+Hardmock 1.3.7
+
+* BUG FIX: expects! could not setup expectations for more than one concrete method on an object, since the method aliasing and rewriting was only taking place when the background mock instance was first created.  This logic has been updated and now you can do all the things you'd expect.
+
+Hardmock 1.3.6
+
+* BUG FIX: In Rails apps (and others) Hardmock and Fixtures battled viciously over "setup" and "teardown" and "method_added" (and any other clever test enhancement tool, namely Mocha) causing unpredictable results, notably failure to auto-verify mocks after teardown (leading to false positive tests).
+  * The newly-added TestUnitBeforeAfter provides TestCase.before_setup and TestCase.after_teardown -- formal test wrapping hooks -- lets Hardmock provide its preparation and auto-verify behavior without contending for setup/teardown supremacy.  
+
+Hardmock 1.3.5
+
+* Aliased should_receive => expects and and_return => returns for easier transition from rspec mock and flexmock users.
+
+Hardmock 1.3.4
+
+* Prevents accidental stubbing and mocking on NilClasses
+
+Hardmock 1.3.3
+ 
+* stubs! and expects! no longer require that their target methods exist in reality (this used to prevent you from stubbing methods that "exist" by virtue of "method_missing"
+* Tweaked inner metaclass code to avoid collisions with rspec's "metaid" stuff
+* Moved this project's Rake tasks into rake_tasks... otherwise Rails will load them, if Hardmock is installed as a Rails plugin
+* Alias added: 'verify_hardmocks' is now an alias for 'verify_mocks'  (some internal projects were using this modified method name as a means of cooexisting with mocha)
+
+Hardmock 1.3.2
+
+November 2007
+
+* adds 'with' as an alternate syntax for specifying argument expectations.
+
+Hardmock 1.3.1 
+
+October 2007
+
+* Can use stubs! on a mock object 
+* expects! now generates mocked methods that can safely transfer runtime blocks to the mock instance itself 
+* No longer need to call "prepare_hardmock_control" when using stubs in the absence of mocks 
+* Stubs of concrete class or instance methods are restored to original state in teardown
+
+Hardmock 1.3.0 
+
+October 2007
+
+* Adds stubs! and expects! method to all objects and classes to support concrete stubbing/mocking.
+
+Hardmock 1.2.3
+
+Sat Apr 28 01:16:15 EDT 2007
+
+* Re-release of 1.2.2 (which was canceled)... tasks moved to lib/tasks
+
+Hardmock 1.2.2
+
+Sat Apr 28 00:41:30 EDT 2007
+
+* assert_error has been broken out into its own lib file
+* Gem package can now run all tests successfully
+* Internal code refactoring; a number of classes that were defined in hardmock.rb are now in their own files
+
+Hardmock 1.2.1
+
+Sat Apr 28 00:41:30 EDT 2007
+
+* (botched release, see 1.2.2)
+
+Hardmock 1.2.0
+
+* You can now use "expect" in place of "expects" if you must. 
+* "inspect" has been added to the list of methods NOT erased by MethodCleanout.
+
+Hardmock 1.1.0
+
+* "expects" replaces "expect" ("expect" now raises Hardmock::DeprecationError)
+* "verify_mocks" is now implicit in teardown, you needn't call it anymore
+* Mocking methods that Mock would otherwise inherit from Object (eg, to_s) is now possible
+* require 'hardmock' is all that's required to use the library now; no need to include in TestCase
+
+(previously called CMock, translated to Hardmock on 2006-12-10)

data/vendor/hardmock-1.3.7/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006,2007 David Crosby at Atomic Object, LLC
+
+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/vendor/hardmock-1.3.7/README

@@ -0,0 +1,70 @@
+== Hardmock
+
+Strict, ordered mock objects using very lightweight syntax in your tests.
+
+== How
+
+The basic procedure for using Hardmock in your tests is:
+
+* require 'hardmock' (this happens automatically when being used as a Rails plugin)
+* Create some mocks
+* Setup some expectations
+* Execute the target code
+* Verification of calls is automatic in =teardown=
+
+The expectations you set when using mocks are <b>strict</b> and <b>ordered</b>.
+Expectations you declare by creating and using mocks are all considered together.
+
+* Hardmock::Mock#expects will show you more examples
+* Hardmock::SimpleExpectation will teach you more about expectation methods
+
+== Example
+
+  create_mocks :garage, :car
+
+  # Set some expectations
+  @garage.expects.open_door
+  @car.expects.start(:choke)
+  @car.expects.drive(:reverse, 5.mph)
+
+  # Execute the code (this code is usually, obviously, in your class under test)
+  @garage.open_door  
+  @car.start :choke
+  @car.drive :reverse, 5.mph
+
+  verify_mocks # OPTIONAL, teardown will do this for you
+
+Expects <tt>@garage.open_door</tt>, <tt>@car.start(:choke)</tt> and <tt>@car.drive(:reverse, 5.mph)</tt> to be called in that order, with those specific arguments.
+* Violations of expectations, such as mis-ordered calls, calls on wrong objects, or incorrect methods result in Hardmock::ExpectationError
+* <tt>verify_mocks</tt> will raise VerifyError if not all expectations have been met.
+
+== Download and Install
+
+* Homepage: http://hardmock.rubyforge.org
+* GEM or TGZ or ZIP: http://rubyforge.org/frs/?group_id=2742
+* Rails plugin: script/plugin install 
+* SVN access: svn co svn://rubyforge.org/var/svn/hardmock/trunk
+* Developer SVN access: svn co svn://developername@rubyforge.org/var/svn/hardmock/trunk
+
+== Setup for Test::Unit
+
+  require 'hardmock'
+  require 'assert_error' # OPTIONAL: this adds the TestUnit extension 'assert_error' 
+
+NOTE: If installed as a Rails plugin, init.rb does this for you... nothing else is needed.
+
+== Setup for RSpec
+
+Get this into your spec helper or environment or Rakefile or wherever you prefer:
+
+  Spec::Runner.configure do |configuration|
+    configuration.include Hardmock
+    configuration.after(:each) {verify_mocks}
+  end
+
+This puts the implicit conveniences into your spec context, like "create_mocks" etc, and also provides for automatic
+"verify_mocks" after each Example is run.
+
+== Author
+* David Crosby crosby at http://atomicobject.com
+* (c) 2006,2007 Atomic Object LLC 

data/vendor/hardmock-1.3.7/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rubygems'
+
+HARDMOCK_VERSION = "1.3.7"
+
+Dir["rake_tasks/*.rake"].each { |f| load f }
+
+task :default => [ 'test:all' ]

data/vendor/hardmock-1.3.7/config/environment.rb

@@ -0,0 +1,12 @@
+# The path to the root directory of your application.
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+ADDITIONAL_LOAD_PATHS = []
+ADDITIONAL_LOAD_PATHS.concat %w(
+  lib 
+).map { |dir| "#{APP_ROOT}/#{dir}" }.select { |dir| File.directory?(dir) }
+
+# Prepend to $LOAD_PATH
+ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) }
+
+# Require any additional libraries needed

data/vendor/hardmock-1.3.7/lib/assert_error.rb

@@ -0,0 +1,23 @@
+require 'test/unit/assertions'
+
+module Test::Unit #:nodoc:#
+  module Assertions #:nodoc:#
+    # A better 'assert_raise'.  +patterns+ can be one or more Regexps, or a literal String that 
+    # must match the entire error message.
+    def assert_error(err_type,*patterns,&block)
+      assert_not_nil block, "assert_error requires a block"
+      assert((err_type and err_type.kind_of?(Class)), "First argument to assert_error has to be an error type")
+      err = assert_raise(err_type) do
+        block.call
+      end
+      patterns.each do |pattern|
+        case pattern
+        when Regexp
+          assert_match(pattern, err.message) 
+        else
+          assert_equal pattern, err.message
+        end
+      end
+    end
+  end
+end

data/vendor/hardmock-1.3.7/lib/extend_test_unit.rb

@@ -0,0 +1,14 @@
+
+require 'test/unit/testcase'
+class Test::Unit::TestCase 
+  include Hardmock
+end
+
+require 'test_unit_before_after'
+Test::Unit::TestCase.before_setup do |test|
+  test.prepare_hardmock_control
+end
+
+Test::Unit::TestCase.after_teardown do |test|
+  test.verify_mocks
+end

data/vendor/hardmock-1.3.7/lib/hardmock.rb

@@ -0,0 +1,86 @@
+require 'hardmock/method_cleanout'
+require 'hardmock/mock'
+require 'hardmock/mock_control'
+require 'hardmock/utils'
+require 'hardmock/errors'
+require 'hardmock/trapper'
+require 'hardmock/expector'
+require 'hardmock/expectation'
+require 'hardmock/expectation_builder'
+require 'hardmock/stubbing'
+
+module Hardmock
+
+  # Create one or more new Mock instances in your test suite. 
+  # Once created, the Mocks are accessible as instance variables in your test.
+  # Newly built Mocks are added to the full set of Mocks for this test, which will
+  # be verified when you call verify_mocks.
+  #
+  #   create_mocks :donkey, :cat # Your test now has @donkey and @cat
+  #   create_mock  :dog          # Test now has @donkey, @cat and @dog
+  #   
+  # The first call returned a hash { :donkey => @donkey, :cat => @cat }
+  # and the second call returned { :dog => @dog }
+  #
+  # For more info on how to use your mocks, see Mock and Expectation
+  #
+  def create_mocks(*mock_names)
+    prepare_hardmock_control unless @main_mock_control
+
+    mocks = {}
+    mock_names.each do |mock_name|
+      raise ArgumentError, "'nil' is not a valid name for a mock" if mock_name.nil?
+      mock_name = mock_name.to_s
+      mock_object = Mock.new(mock_name, @main_mock_control)
+      mocks[mock_name.to_sym] = mock_object
+      self.instance_variable_set "@#{mock_name}", mock_object
+    end
+    @all_mocks ||= {}
+    @all_mocks.merge! mocks
+
+    return mocks.clone
+  end
+
+  def prepare_hardmock_control
+    if @main_mock_control.nil?
+      @main_mock_control = MockControl.new
+      $main_mock_control = @main_mock_control
+    else
+      raise "@main_mock_control is already setup for this test!"
+    end
+  end
+
+  alias :create_mock :create_mocks
+
+  # Ensures that all expectations have been met.  If not, VerifyException is
+  # raised.
+  #
+  # <b>You normally won't need to call this yourself.</b> Within Test::Unit::TestCase, this will be done automatically at teardown time.
+  #
+  # * +force+ -- if +false+, and a VerifyError or ExpectationError has already occurred, this method will not raise.  This is to help you suppress repeated errors when if you're calling #verify_mocks in the teardown method of your test suite.  BE WARNED - only use this if you're sure you aren't obscuring useful information.  Eg, if your code handles exceptions internally, and an ExpectationError gets gobbled up by your +rescue+ block, the cause of failure for your test may be hidden from you.  For this reason, #verify_mocks defaults to force=true as of Hardmock 1.0.1
+  def verify_mocks(force=true)
+    return unless @main_mock_control
+    return if @main_mock_control.disappointed? and !force
+    @main_mock_control.verify
+  ensure
+    @main_mock_control.clear_expectations if @main_mock_control
+    $main_mock_control = nil
+    reset_stubs
+  end
+  
+  alias :verify_hardmocks :verify_mocks
+
+  # Purge the main MockControl of all expectations, restore all concrete stubbed/mocked methods
+  def clear_expectations
+    @main_mock_control.clear_expectations if @main_mock_control
+    reset_stubs
+    $main_mock_control = nil
+  end
+
+  def reset_stubs
+    Hardmock.restore_all_replaced_methods
+  end
+
+end
+
+require 'extend_test_unit'