glib2 0.90.8-x86-mingw32 → 0.90.9-x86-mingw32

data/test-unit/lib/test/unit/util/backtracefilter.rb

@@ -1,42 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module BacktraceFilter
-        TESTUNIT_FILE_SEPARATORS = %r{[\\/:]}
-        TESTUNIT_PREFIX = __FILE__.split(TESTUNIT_FILE_SEPARATORS)[0..-3]
-        TESTUNIT_RB_FILE = /\.rb\Z/
-
-        module_function
-        def filter_backtrace(backtrace, prefix=nil)
-          return ["No backtrace"] unless(backtrace)
-          return backtrace if ENV["TEST_UNIT_ALL_BACKTRACE"]
-          split_p = if(prefix)
-            prefix.split(TESTUNIT_FILE_SEPARATORS)
-          else
-            TESTUNIT_PREFIX
-          end
-          match = proc do |e|
-            split_e = e.split(TESTUNIT_FILE_SEPARATORS)[0, split_p.size]
-            next false unless(split_e[0..-2] == split_p[0..-2])
-            split_e[-1].sub(TESTUNIT_RB_FILE, '') == split_p[-1]
-          end
-          return backtrace unless(backtrace.detect(&match))
-          found_prefix = false
-          new_backtrace = backtrace.reverse.reject do |e|
-            if(match[e])
-              found_prefix = true
-              true
-            elsif(found_prefix)
-              false
-            else
-              true
-            end
-          end.reverse
-          new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
-          new_backtrace = new_backtrace.reject(&match)
-          new_backtrace.empty? ? backtrace : new_backtrace
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/util/method-owner-finder.rb

@@ -1,28 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module MethodOwnerFinder
-        module_function
-        def find(object, method_name)
-          method = object.method(method_name)
-          return method.owner if method.respond_to?(:owner)
-
-          if /\((.+?)\)\#/ =~ method.to_s
-            owner_name = $1
-            if /\A#</ =~ owner_name
-              ObjectSpace.each_object(Module) do |mod|
-                return mod if mod.to_s == owner_name
-              end
-            else
-              owner_name.split(/::/).inject(Object) do |parent, name|
-                parent.const_get(name)
-              end
-            end
-          else
-            object.class
-          end
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/util/observable.rb

@@ -1,90 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/util/procwrapper'
-
-module Test
-  module Unit
-    module Util
-
-      # This is a utility class that allows anything mixing
-      # it in to notify a set of listeners about interesting
-      # events.
-      module Observable
-        # We use this for defaults since nil might mean something
-        NOTHING = "NOTHING/#{__id__}"
-
-        # Adds the passed proc as a listener on the
-        # channel indicated by channel_name. listener_key
-        # is used to remove the listener later; if none is
-        # specified, the proc itself is used.
-        #
-        # Whatever is used as the listener_key is
-        # returned, making it very easy to use the proc
-        # itself as the listener_key:
-        #
-        #  listener = add_listener("Channel") { ... }
-        #  remove_listener("Channel", listener)
-        def add_listener(channel_name, listener_key=NOTHING, &listener) # :yields: value
-          unless(block_given?)
-            raise ArgumentError.new("No callback was passed as a listener")
-          end
-      
-          key = listener_key
-          if (listener_key == NOTHING)
-            listener_key = listener
-            key = ProcWrapper.new(listener)
-          end
-      
-          channels[channel_name] ||= {}
-          channels[channel_name][key] = listener
-          return listener_key
-        end
-
-        # Removes the listener indicated by listener_key
-        # from the channel indicated by
-        # channel_name. Returns the registered proc, or
-        # nil if none was found.
-        def remove_listener(channel_name, listener_key)
-          channel = channels[channel_name]
-          return nil unless (channel)
-          key = listener_key
-          if (listener_key.instance_of?(Proc))
-            key = ProcWrapper.new(listener_key)
-          end
-          if (channel.has_key?(key))
-            return channel.delete(key)
-          end
-          return nil
-        end
-
-        # Calls all the procs registered on the channel
-        # indicated by channel_name. If value is
-        # specified, it is passed in to the procs,
-        # otherwise they are called with no arguments.
-        #
-        #--
-        #
-        # Perhaps this should be private? Would it ever
-        # make sense for an external class to call this
-        # method directly?
-        def notify_listeners(channel_name, *arguments)
-          channel = channels[channel_name]
-          return 0 unless (channel)
-          listeners = channel.values
-          listeners.each { |listener| listener.call(*arguments) }
-          return listeners.size
-        end
-
-        private
-        def channels
-          @channels ||= {}
-          return @channels
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/util/output.rb

@@ -1,31 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module Output
-        ##
-        # Returns output for standard output and standard
-        # error as string.
-        #
-        # Example:
-        #   capture_output do
-        #     puts("stdout")
-        #     warn("stderr")
-        #   end # -> ["stdout\n", "stderr\n"]
-        def capture_output
-          require 'stringio'
-
-          output = StringIO.new
-          error = StringIO.new
-          stdout_save, stderr_save = $stdout, $stderr
-          $stdout, $stderr = output, error
-          begin
-            yield
-            [output.string, error.string]
-          ensure
-            $stdout, $stderr = stdout_save, stderr_save
-          end
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/util/procwrapper.rb

@@ -1,48 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-module Test
-  module Unit
-    module Util
-
-      # Allows the storage of a Proc passed through '&' in a
-      # hash.
-      #
-      # Note: this may be inefficient, since the hash being
-      # used is not necessarily very good. In Observable,
-      # efficiency is not too important, since the hash is
-      # only accessed when adding and removing listeners,
-      # not when notifying.
-
-      class ProcWrapper
-
-        # Creates a new wrapper for a_proc.
-        def initialize(a_proc)
-          @a_proc = a_proc
-          @hash = a_proc.inspect.sub(/^(#<#{a_proc.class}:)/){''}.sub(/(>)$/){''}.hex
-        end
-
-        def hash
-          return @hash
-        end
-
-        def ==(other)
-          case(other)
-            when ProcWrapper
-              return @a_proc == other.to_proc
-            else
-              return super
-          end
-        end
-        alias :eql? :==
-
-        def to_proc
-          return @a_proc
-        end
-      end
-    end
-  end
-end

data/test-unit/lib/test/unit/version.rb

@@ -1,7 +0,0 @@
-
-# HACK: quick and dirty to get integrated into the new project - ryan
-module Test
-  module Unit
-    VERSION = '2.2.1'
-  end
-end

data/test-unit/sample/adder.rb

@@ -1,13 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-class Adder
-  def initialize(number)
-    @number = number
-  end
-  def add(number)
-    return @number + number
-  end
-end
-

data/test-unit/sample/subtracter.rb

@@ -1,12 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-class Subtracter
-  def initialize(number)
-    @number = number
-  end
-  def subtract(number)
-    return @number - number
-  end
-end

data/test-unit/sample/test_adder.rb

@@ -1,20 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-require 'adder'
-
-class TestAdder < Test::Unit::TestCase
-  def setup
-    @adder = Adder.new(5)
-  end
-
-  def test_add
-    assert_equal(7, @adder.add(2), "Should have added correctly")
-  end
-
-  def teardown
-    @adder = nil
-  end
-end

data/test-unit/sample/test_subtracter.rb

@@ -1,20 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit'
-require 'subtracter'
-
-class TestSubtracter < Test::Unit::TestCase
-  def setup
-    @subtracter = Subtracter.new(5)
-  end
-
-  def test_subtract
-    assert_equal(3, @subtracter.subtract(2), "Should have subtracted correctly")
-  end
-
-  def teardown
-    @subtracter = nil
-  end
-end

data/test-unit/sample/test_user.rb

@@ -1,23 +0,0 @@
-# nested test case example.
-require 'test/unit'
-
-class UserTest < Test::Unit::TestCase
-  def setup
-    @user = "me"
-  end
-
-  def test_full_name
-    assert_equal("me", @user)
-  end
-
-  class ProfileTest < UserTest
-    setup
-    def setup_profile
-      @user += ": profile"
-    end
-
-    def test_has_profile
-      assert_match(/: profile/, @user)
-    end
-  end
-end

data/test-unit/test/collector/test-descendant.rb

@@ -1,133 +0,0 @@
-require 'test/unit'
-require 'test/unit/collector/descendant'
-
-class TestUnitCollectorDescendant < Test::Unit::TestCase
-  def setup
-    @previous_descendants = Test::Unit::TestCase::DESCENDANTS.dup
-    Test::Unit::TestCase::DESCENDANTS.clear
-
-    @test_case1 = Class.new(Test::Unit::TestCase) do
-      def self.name
-        "test-case1"
-      end
-
-      def test_1
-      end
-
-      def test_2
-      end
-    end
-
-    @test_case2 = Class.new(Test::Unit::TestCase) do
-      def self.name
-        "test-case2"
-      end
-
-      def test_0
-      end
-    end
-
-    @no_test_case = Class.new do
-      def self.name
-        "no-test-case"
-      end
-
-      def test_4
-      end
-    end
-  end
-
-  def teardown
-    Test::Unit::TestCase::DESCENDANTS.replace(@previous_descendants)
-  end
-
-  def test_basic_collection
-    assert_collect(full_suite("name"), "name")
-
-    assert_collect(full_suite("name"), "name") do |collector|
-      collector.filter = []
-    end
-  end
-
-  def test_filtered_collection
-    assert_collect(empty_suite) do |collector|
-      collector.filter = Proc.new {false}
-    end
-
-    assert_collect(full_suite) do |collector|
-      collector.filter = Proc.new {true}
-    end
-
-    assert_collect(full_suite) do |collector|
-      collector.filter = Proc.new {nil}
-    end
-
-    assert_collect(empty_suite) do |collector|
-      collector.filter = [Proc.new {false}, Proc.new {true}]
-    end
-
-    assert_collect(empty_suite) do |collector|
-      collector.filter = [Proc.new {true}, Proc.new {false}]
-    end
-
-    assert_collect(empty_suite) do |collector|
-      collector.filter = [Proc.new {nil}, Proc.new {false}]
-    end
-
-    assert_collect(full_suite) do |collector|
-      collector.filter = [Proc.new {nil}, Proc.new {true}]
-    end
-
-    expected = empty_suite
-    suite1 = Test::Unit::TestSuite.new(@test_case1.name)
-    suite1 << @test_case1.new("test_1")
-    suite2 = Test::Unit::TestSuite.new(@test_case2.name)
-    suite2 << @test_case2.new("test_0")
-    expected << suite1 << suite2
-    assert_collect(expected) do |collector|
-      collector.filter = Proc.new do |test|
-        ['test_1', 'test_0'].include?(test.method_name)
-      end
-    end
-
-    suite1 = Test::Unit::TestSuite.new(@test_case1.name)
-    suite1 << @test_case1.new("test_1")
-    suite2 = Test::Unit::TestSuite.new(@test_case2.name)
-    suite2 << @test_case2.new("test_0")
-    assert_collect(empty_suite) do |collector|
-      filters = [Proc.new {|test| test.method_name == 'test_1' ? true : nil},
-                 Proc.new {|test| test.method_name == 'test_0' ? true : nil},
-                 Proc.new {false}]
-      collector.filter = filters
-    end
-  end
-
-  private
-  def assert_collect(expected, *collect_args)
-    collector = Test::Unit::Collector::Descendant.new
-    yield(collector) if block_given?
-    assert_equal(expected, collector.send(:collect, *collect_args))
-  end
-
-  def default_name
-    Test::Unit::Collector::Descendant::NAME
-  end
-
-  def empty_suite(name=nil)
-    Test::Unit::TestSuite.new(name || default_name)
-  end
-
-  def full_suite(name=nil)
-    sub_suite1 = Test::Unit::TestSuite.new(@test_case1.name)
-    sub_suite1 << @test_case1.new('test_1')
-    sub_suite1 << @test_case1.new('test_2')
-
-    sub_suite2 = Test::Unit::TestSuite.new(@test_case2.name)
-    sub_suite2 << @test_case2.new('test_0')
-
-    suite = empty_suite(name)
-    suite << sub_suite1
-    suite << sub_suite2
-    suite
-  end
-end