social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/p_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+require 'tins/xt/p'
+
+module Tins
+  class PTest < Test::Unit::TestCase
+    def test_p_bang
+      assert_raise(RuntimeError) { p! "foo" }
+    end
+
+    def test_pp_bang
+      assert_raise(RuntimeError) { pp! "foo" }
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/partial_application_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class PartialApplicationTest < Test::Unit::TestCase
+
+    def mul(x, y) x * y end
+
+    define_method(:dup) { |y| method(:mul).partial(2)[y] }
+
+    define_method(:trip) { |y| method(:mul).partial(3)[y] }
+
+
+    def test_proc
+      mul   = lambda { |x, y| x * y }
+      klon  = mul.partial
+      dup   = mul.partial(2)
+      trip  = mul.partial(3)
+      assert_equal [ 6, 9, 12 ], [ dup[3], trip[3], mul[4, 3] ]
+      assert_equal [ 6, 9, 12 ], [ dup[3], trip[3], klon[4, 3] ]
+      assert_raises(ArgumentError) do
+        mul.partial(1, 2, 3)
+      end
+    end
+
+    def test_method
+      assert_equal [ 6, 9, 12 ], [ dup(3), trip(3), mul(4, 3) ]
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/proc_compose_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class ProcComposeTest < Test::Unit::TestCase
+
+    def test_proc_compose_simple
+      f = lambda { |x| 2 * x }
+      g = lambda { |x| x + 1 }
+      assert_equal 6, (f * g).call(2)
+    end
+
+    def test_proc_compose_more_complex
+      f = lambda { |x, y| 2 * x + y * 3 }
+      g = lambda { |x| x + 1 }
+      if RUBY_VERSION >= "1.9"
+        assert_raise(ArgumentError) { (f * g).call(2, 3) }
+      else
+        assert_raise(TypeError) { (f * g).call(2, 3) }
+      end
+      d = lambda { |x| [ x, x ] }
+      assert_equal 15, (f * d * g).call(2)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/proc_prelude_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+require 'tins/xt/proc_prelude'
+
+module Tins
+  class ProcPreludeTest < Test::Unit::TestCase
+    def test_apply
+      assert_equal 42,
+        Proc.apply { |x, y, z|  x ** 2 + y ** 3 + z ** 5 }.call([3, 1, 2])
+    end
+
+    class Person
+      def initialize(name)
+        @name = name
+      end
+
+      attr_reader :name
+    end
+
+    def test_map_apply
+      ps = %w[anne bernd christian].map { |n| Person.new(n) }
+
+      i = 0
+      assert_equal %w[ anne1 bernd2 christian3 ],
+        ps.inject([], &Proc.map_apply(:name) { |s, n| s << "#{n}#{i += 1}" })
+    end
+
+    def test_call
+      def (o = Object.new).foo
+        :foo
+      end
+      assert_equal :foo, Proc.call(o) { foo }
+    end
+
+    def test_array
+      assert_equal [1,2,3], Proc.array.call(1,2,3)
+    end
+
+    def test_first
+      assert_equal 1, Proc.first.call(1,2,3)
+      assert_equal 1, Proc.head.call(1,2,3)
+    end
+
+    def test_second
+      assert_equal 2, Proc.second.call(1,2,3)
+    end
+
+    def test_tail
+      assert_equal [ 2, 3 ], Proc.tail.call(1,2,3)
+    end
+
+    def test_last
+      assert_equal 3, Proc.last.call(1,2,3)
+    end
+
+    def test_rotate
+      assert_equal [ 2, 3, 1 ], Proc.rotate.call(1,2,3)
+      assert_equal [ 2, 1 ], Proc.swap.call(1,2)
+    end
+
+    def test_id1
+      assert_equal :foo, Proc.id1.call(:foo)
+    end
+
+    def test_const
+      assert_equal :baz, Proc.const(:baz).call(:foo, :bar)
+      assert_equal :baz, Proc.const { :baz }.call(:foo, :bar)
+    end
+
+    def test_nth
+      assert_equal 2, Proc.nth(1).call(1,2,3)
+    end
+
+    def square(x)
+      x ** 2
+    end
+
+    def test_from
+      assert_equal [ 1, 4, 9 ], [ 1, 2, 3 ].map(&Proc.from{:square})
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/range_plus_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class RangePlustTest < Test::Unit::TestCase
+
+    def test_range_plus
+      assert_equal [], (0...0) + (0...0)
+      assert_equal [ 0 ], (0..0) + (0...0)
+      assert_equal [ 0, 0 ], (0..0) + (0..0)
+      assert_equal((1..5).to_a, (1...3) + (3..5))
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/require_maybe_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  require 'tins/xt/require_maybe'
+  class RequireMaybeTest < Test::Unit::TestCase
+    def test_require_maybe_failed
+      executed = false
+      require_maybe 'nix' do
+        executed = true
+      end
+      assert executed, 'require did not fail'
+    end
+
+    def test_require_maybe_succeeded
+      not_executed = true
+      result = require_maybe 'tins' do
+        not_executed = false
+      end
+      assert [ false, true ].include?(result)
+      assert not_executed, 'require failed'
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/responding_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class RespondingTest < Test::Unit::TestCase
+    class A
+      def foo() end
+
+      def bar() end
+    end
+
+    def test_responding
+      assert_equal true, responding?(:foo) === A.new
+      assert_equal false, responding?(:jflafjdklfjaslkdfj) === A.new
+      assert_equal false, responding?(:jflafjdklfjaslkdfj, :foo) === A.new
+      assert_equal true, responding?(:foo, :bar) === A.new
+    end
+
+    def test_responding_to_s
+      assert_equal 'Responding to foo', responding?(:foo).to_s
+      assert_equal 'Responding to foo', responding?(:foo).inspect
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/rotate_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+module Tins
+  class RotateTest < Test::Unit::TestCase
+    def test_rotate_bang
+      a = [ 1, 2, 3 ]
+      assert_same a, a.rotate!
+    end
+
+    def test_rotate_bang_0
+      a = [ 1, 2, 3 ]
+      assert_equal [ 1, 2, 3 ], a.rotate!(0)
+    end
+
+    def test_rotate_bang_1
+      a = [ 1, 2, 3 ]
+      assert_equal [ 2, 3, 1 ], a.rotate!(1)
+    end
+
+    def test_rotate_bang_2
+      a = [ 1, 2, 3 ]
+      assert_equal [ 3, 1, 2 ], a.rotate!(2)
+    end
+
+    def test_rotate_bang_minus_1
+      a = [ 1, 2, 3 ]
+      assert_equal [ 3, 1, 2 ], a.rotate!(-1)
+    end
+
+    def test_rotate_bang_minus_2
+      a = [ 1, 2, 3 ]
+      assert_equal [ 2, 3, 1 ], a.rotate!(-2)
+    end
+
+    def test_rotate
+      a = [ 1, 2, 3 ]
+      assert_not_same a, a.rotate
+    end
+
+    def test_rotate_0
+      a = [ 1, 2, 3 ]
+      assert_equal [ 1, 2, 3 ], a.rotate(0)
+    end
+
+    def test_rotate_1
+      a = [ 1, 2, 3 ]
+      assert_equal [ 2, 3, 1 ], a.rotate(1)
+    end
+
+    def test_rotate_2
+      a = [ 1, 2, 3 ]
+      assert_equal [ 3, 1, 2 ], a.rotate(2)
+    end
+
+    def test_rotate_minus_1
+      a = [ 1, 2, 3 ]
+      assert_equal [ 3, 1, 2 ], a.rotate(-1)
+    end
+
+    def test_rotate_minus_2
+      a = [ 1, 2, 3 ]
+      assert_equal [ 2, 3, 1 ], a.rotate(-2)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/round_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class RoundTest < Test::Unit::TestCase
+
+    def test_standard
+      assert_equal(1, 1.round)
+      assert_equal(-1, -1.round)
+      assert_equal(2, 1.5.round)
+      assert_kind_of Integer, 1.5.round
+      assert_equal(-1, -1.4.round)
+      assert_equal(-2, -1.5.round)
+    end
+
+    def test_inclusion
+      assert_equal(10, 12.round(-1))
+      assert_kind_of Integer, 12.round(-1)
+      assert_equal(-10, -12.round(-1))
+      assert_raises(ArgumentError) { 12.round(-2) }
+      assert_raises(ArgumentError) { -12.round(-2) }
+      assert_in_delta(1.6, 1.55.round(1), 1E-1)
+      assert_kind_of Float, 1.55.round(1)
+      assert_equal(2, 1.55.round(0))
+      assert_in_delta(-1.5, -1.45.round(1), 1E-1)
+      assert_equal(-1, -1.45.round(0))
+      assert_in_delta(-1.6, -1.55.round(1), 1E-1)
+      assert_equal(-2, -1.55.round(0))
+      assert_in_delta(-1.55, -1.55.round(999), 1E-2)
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/secure_write_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'tempfile'
+require 'tins'
+
+module Tins
+  class TinsSecureWriteTest < Test::Unit::TestCase
+    module A
+      extend SecureWrite
+    end
+
+    def test_secure_write
+      assert_equal 4, A.secure_write(fn = File.join(Dir.tmpdir, "A_file.#$$"), 'test')
+      assert_equal 4, A.secure_write(fn = File.join(Dir.tmpdir, "A_file.#$$")) { |f| f.write('test') }
+      assert_equal 'test', File.read(fn)
+      assert_raise(ArgumentError) { A.secure_write }
+    end
+
+    module B
+      extend Write
+    end
+
+    module C
+      def self.write(*args)
+        args
+      end
+      extend Write
+    end
+
+    class ::IO
+      extend Write
+    end
+
+    def test_write
+      assert_equal 4, B.write(fn = File.join(Dir.tmpdir, "B_file.#$$"), 'test')
+      assert_equal 4, B.write(fn = File.join(Dir.tmpdir, "B_file.#$$")) { |f| f.write('test') }
+      assert_equal 4, IO.write(fn = File.join(Dir.tmpdir, "IO_file.#$$"), 'test')
+      assert_equal 'test', File.read(fn)
+      result = C.write(fn = File.join(Dir.tmpdir, "C_file.#$$"), 'test')
+      assert_equal [ fn, 'test' ], result
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/sexy_singleton_test.rb

@@ -0,0 +1,16 @@
+require 'tins'
+
+class SexySingletonTest < Test::Unit::TestCase
+  class Single
+    include Tins::SexySingleton
+
+    def foo
+      :foo
+    end
+  end
+
+  def test_foo
+    assert_equal :foo, Single.instance.foo
+    assert_equal :foo, Single.foo
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/shuffle_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  if Tins::Shuffle === Array
+    class ShuffleTest < Test::Unit::TestCase
+
+      def setup
+        @a = [ 1, 2, 3 ]
+        srand 666
+      end
+
+      def test_shuffle
+        assert_equal(a = [2, 3, 1], a = @a.shuffle)
+        assert_not_same @a, a
+        assert_equal(b = [3, 1, 2], b = @a.shuffle)
+        assert_not_same a, b
+        assert_not_same @a, b
+      end
+
+      def test_shuffle_bang
+        assert_equal([2, 3, 1], a = @a.shuffle!)
+        assert_same @a, a
+        assert_equal([1, 2, 3], b = @a.shuffle!)
+        assert_same a, b
+        assert_same @a, b
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/tins-0.13.1/tests/string_byte_order_mark_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  if defined? ::Encoding
+    class StringByteOrderMarkTest < Test::Unit::TestCase
+      def test_no_bom_encoding
+        assert_nil "abcdef".bom_encoding
+      end
+
+      def test_utf8_bom_encoding
+        assert_equal Encoding::UTF_8, "\xef\xbb\xbf".bom_encoding
+      end
+
+      def test_utf16be_bom_encoding
+        assert_equal Encoding::UTF_16BE, "\xfe\xff".bom_encoding
+      end
+
+      def test_utf16le_bom_encoding
+        assert_equal Encoding::UTF_16LE, "\xff\xfe".bom_encoding
+      end
+
+      def test_utf32be_bom_encoding
+        assert_equal Encoding::UTF_32BE, "\x00\x00\xff\xfe".bom_encoding
+      end
+
+      def test_utf32le_bom_encoding
+        assert_equal Encoding::UTF_32LE, "\xff\xfe\x00\x00".bom_encoding
+      end
+
+      def test_utf7_bom_encoding
+        assert_equal Encoding::UTF_7, "\x2b\x2f\x76\x38".bom_encoding
+        assert_equal Encoding::UTF_7, "\x2b\x2f\x76\x39".bom_encoding
+        assert_equal Encoding::UTF_7, "\x2b\x2f\x76\x2b".bom_encoding
+        assert_equal Encoding::UTF_7, "\x2b\x2f\x76\x2f".bom_encoding
+        assert_equal Encoding::UTF_7, "\x2b\x2f\x76\x38\x2d".bom_encoding
+      end
+    end
+  end
+end