opal 0.3.18 → 0.3.19

data/test/core/hash/select_spec.rb

@@ -0,0 +1,52 @@
+describe "Hash#select" do
+  before(:each) do
+    @hsh = {1 => 2, 3 => 4, 5 => 6}
+    @empty = {}
+  end
+
+  it "yields two arguments: key and value" do
+    all_args = []
+    {1 => 2, 3 => 4}.select { |*args| all_args << args }
+    all_args.should == [[1, 2], [3, 4]]
+  end
+
+  it "returns a Hash of entries for which block is true" do
+    a_pairs = {'a' => 9, 'c' => 4, 'b' => 5, 'd' => 2}.select { |k,v| v % 2 == 0 }
+    a_pairs.should be_kind_of(Hash)
+    a_pairs.should == {'c' => 4, 'd' => 2}
+  end
+
+  it "processes entries with the same order as reject" do
+    h = {:a => 9, :c => 4, :b => 5, :d => 2}
+
+    select_pairs = []
+    reject_pairs = []
+    h.select { |*pair| select_pairs << pair }
+    h.reject { |*pair| reject_pairs << pair }
+
+    select_pairs.should == reject_pairs
+  end
+end
+
+describe "Hash#select!" do
+  before(:each) do
+    @hsh = {1 => 2, 3 => 4, 5 => 6}
+    @empty = {}
+  end
+
+  it "is equivalent to keep_if if changes are made" do
+    {:a => 2}.select! { |k,v| v <= 1 }.should ==
+      {:a => 2}.keep_if { |k, v| v <= 1 }
+
+    h = {1 => 2, 3 => 4}
+    all_args_select = []
+    all_args_keep_if = []
+    h.dup.select! { |*args| all_args_select << args }
+    h.dup.keep_if { |*args| all_args_keep_if << args }
+    all_args_select.should == all_args_keep_if
+  end
+
+  it "returns nil if no changes were made" do
+    {:a => 1}.select! { |k,v| v <= 1 }.should == nil
+  end
+end

data/test/core/hash/shift_spec.rb

@@ -0,0 +1,19 @@
+describe "Hash#shift" do
+  it "removes a pair from hash and return it" do
+    h = {:a => 1, :b => 2, "c" => 3, nil => 4, [] => 5}
+    h2 = h.dup
+
+    h.size.times do |i|
+      r = h.shift
+      # r.should be_kind_of(Array)
+      # h2[r.first].should == r.last
+      # h.size.should == h2.size - i - 1
+    end
+
+    h.should == {}
+  end
+
+  it "removes nil from an empty hash" do
+    {}.shift.should == nil
+  end
+end

data/test/core/hash/size_spec.rb

@@ -0,0 +1,10 @@
+describe "Hash#size" do
+  it "returns the number of entries" do
+    {:a => 1, :b => 'c'}.size.should == 2
+    {:a => 1, :b => 2, :a => 2}.size.should == 2
+    {:a => 1, :b => 1, :c => 1}.size.should == 3
+    Hash.new.size.should == 0
+    Hash.new(5).size.should == 0
+    Hash.new { 5 }.size.should == 0
+  end
+end

data/test/core/hash/update_spec.rb

@@ -0,0 +1,17 @@
+describe "Hash#update" do
+  it "adds the entries from other, overwriting duplicate keys. Returns self" do
+    h = {:_1 => 'a', :_2 => '3'}
+    h.update(:_1 => '9', :_9 => 2).should equal(h)
+    h.should == {:_1 => "9", :_2 => "3", :_9 => 2}
+  end
+
+  it "sets any duplicate key to the value of block if passed a block" do
+    h1 = {:a => 2, :b => -1}
+    h2 = {:a => -2, :c => 1}
+    h1.update(h2) { |k,x,y| 3.14 }.should equal(h1)
+    h1.should == {:c => 1, :b => -1, :a => 3.14}
+
+    h1.update(h1) { nil }
+    h1.should == {:a => nil, :b => nil, :c => nil}
+  end
+end

data/test/core/hash/value_spec.rb

@@ -0,0 +1,12 @@
+describe "Hash#value?" do
+  it "returns true if the value exists in the hash" do
+    {:a => :b}.value?(:a).should == false
+    {1 => 2}.value?(2).should == true
+    h = Hash.new 5
+    h.value?(5).should == false
+  end
+
+  it "uses == semantics for comparing values" do
+    {5 => 2.0}.value?(2).should == true
+  end
+end

data/test/core/hash/values_at_spec.rb

@@ -0,0 +1,9 @@
+describe "Hash#values_at" do
+  it "returns an array of values for the given keys" do
+    h = {:a => 9, :b => 'a', :c => -10, :d => nil}
+    h.values_at.should be_kind_of(Array)
+    h.values_at.should == []
+    h.values_at(:a, :d, :b).should be_kind_of(Array)
+    h.values_at(:a, :d, :b).should == [9, nil, 'a']
+  end
+end

data/test/core/hash/values_spec.rb

@@ -0,0 +1,7 @@
+describe "Hash#values" do
+  it "returns an array of values" do
+    h = {1 => :a, 'a' => :a, 'the' => 'lang'}
+    h.values.should be_kind_of(Array)
+    h.values.should == [:a, :a, 'lang']
+  end
+end

data/test/core/kernel/eql_spec.rb

@@ -0,0 +1,15 @@
+describe "Kernel#eql?" do
+  it "returns true if obj and anObject are the same object." do
+    o1 = Object.new
+    o2 = Object.new
+    o1.eql?(o1).should be_true
+    o2.eql?(o2).should be_true
+    o1.eql?(o2).should be_false
+  end
+
+  it "returns true if obj and anObject have the same value." do
+    :hola.eql?(1).should be_false
+    1.eql?(1).should be_true
+    :hola.eql?(:hola).should be_true
+  end
+end

data/test/core/kernel/equal_value_spec.rb

@@ -0,0 +1,12 @@
+describe "Kernel#==" do
+  it "returns true only if obj and other are the same object" do
+    o1 = Object.new
+    o2 = Object.new
+    (o1 == o1).should == true
+    (o2 == o2).should == true
+    (o1 == o2).should == false
+    (nil == nil).should == true
+    (o1 == nil).should == false
+    (nil == o2).should == false
+  end
+end

data/test/core/kernel/loop_spec.rb

@@ -0,0 +1,23 @@
+describe "Kernel.loop" do
+  it "calls block until it is terminated by a break" do
+    i = 0
+    loop do
+      i += 1
+      break if i == 10
+    end
+
+    i.should == 10
+  end
+
+  it "returns value passed to break" do
+    loop do
+      break 123
+    end.should == 123
+  end
+
+  it "returns nil if no value passed to break" do
+    loop do
+      break
+    end.should == nil
+  end
+end

data/test/core/kernel/nil_spec.rb

@@ -0,0 +1,7 @@
+describe "Kernel#nil?" do
+  it "should return false for all object that are not nil" do
+    Object.new.nil?.should be_false
+    0.nil?.should be_false
+    false.nil?.should be_false
+  end
+end

data/test/core/kernel/proc_spec.rb

@@ -0,0 +1,9 @@
+describe "Kernel#proc" do
+  it "returns a Proc object" do
+    proc { true }.kind_of?(Proc).should == true
+  end
+
+  it "raises an ArgumentError when no block is given" do
+    lambda { proc }.should raise_error(ArgumentError)
+  end
+end

data/test/core/kernel/rand_spec.rb

@@ -0,0 +1,14 @@
+describe "Kernel.rand" do
+  it "returns a float if no argument is passed" do
+    # rand.should be_kind_of(Float)
+  end
+
+  it "returns an integer for an integer argument" do
+    # rand(77).should be_kind_of(Integer)
+  end
+
+  it "returns a numeric in opal" do
+    rand.should be_kind_of(Numeric)
+    rand(77).should be_kind_of(Numeric)
+  end
+end

data/test/core/kernel/respond_to_spec.rb

@@ -0,0 +1,24 @@
+class RespondToSpecs
+  def self.bar
+    'done'
+  end
+
+  def undefed_method
+    true
+  end
+
+  undef undefed_method
+end
+
+describe "Kernel.respond_to?" do
+  it "indicates if a singleton object responds to a particular message" do
+    RespondToSpecs.respond_to?(:bar).should == true
+    RespondToSpecs.respond_to?(:baz).should == false
+  end
+end
+
+describe "Kernel#respond_to?" do
+  before :each do
+    @a = RespondToSpecs.new
+  end
+end

data/test/core/kernel/send_spec.rb

@@ -0,0 +1,56 @@
+module KernelSpecs
+  class Foo
+    def bar
+      'done'
+    end
+
+    alias :aka :bar
+
+    def baz(*args) args end
+
+    def foo(first, *rest) [first, *rest] end
+
+    def buz(first = true) first end
+
+    def self.bar
+      'done'
+    end
+  end
+end
+
+describe "Kernel#send" do
+  it "invokes the named public method" do
+    KernelSpecs::Foo.new.send(:bar).should == 'done'
+  end
+
+  it "invokes the named alias of a public method" do
+    KernelSpecs::Foo.new.send(:aka).should == 'done'
+  end
+end
+
+describe "Kernel#send" do
+  it "invokes the named method" do
+    KernelSpecs::Foo.new.send(:bar).should == 'done'
+  end
+
+  it "invokes a class method if called on a class" do
+    KernelSpecs::Foo.send(:bar).should == 'done'
+  end
+
+  it "succeeds if passed an arbitrary number of arguments as a splat parameter" do
+    KernelSpecs::Foo.new.send(:baz).should == []
+    KernelSpecs::Foo.new.send(:baz, :quux).should == [:quux]
+    KernelSpecs::Foo.new.send(:baz, :quux, :foo).should == [:quux, :foo]
+  end
+
+  it "succeeds when passing 1 or more arguments as a required and a splat parameter" do
+    KernelSpecs::Foo.new.send(:foo, :quux).should == [:quux]
+    KernelSpecs::Foo.new.send(:foo, :quux, :bar).should == [:quux, :bar]
+    KernelSpecs::Foo.new.send(:foo, :quux, :bar, :baz).should == [:quux, :bar, :baz]
+  end
+
+  it "succeeds when passing 0 arguments to a method with one parameter with a default" do
+    KernelSpecs::Foo.new.send(:buz).should == true
+    KernelSpecs::Foo.new.send(:buz, :arg).should == :arg
+  end
+end

data/test/core/kernel/tap_spec.rb

@@ -0,0 +1,10 @@
+describe "Kernel#tap" do
+  it "always yields self and returns self" do
+    a = Object.new
+    a.tap {|o| o.should equal(a); 42}.should equal(a)
+  end
+
+  it "raises a LocalJumpError when no block given" do
+    lambda { 3.tap }.should raise_error(LocalJumpError)
+  end
+end

data/test/core/kernel/to_s_spec.rb

@@ -0,0 +1,5 @@
+describe "Kernel#to_s" do
+  it "returns a String containing the name of self's class" do
+    Object.new.to_s.should =~ /Object/
+  end
+end

data/test/core/range/begin_spec.rb

@@ -0,0 +1,9 @@
+describe "Range#begin" do
+  it "returns the first element of self" do
+    (-1..1).begin.should == -1
+    (0..1).begin.should == 0
+    ('Q'..'T').begin.should == 'Q'
+    ('Q'...'T').begin.should == 'Q'
+    (0.5..2.4).begin.should == 0.5
+  end  
+end

data/test/core/range/case_compare_spec.rb

@@ -0,0 +1,16 @@
+describe "Range#===" do
+  it "returns true if other is an element of self" do
+    ((0..5) === 2).should == true
+    ((-5..5) === 0).should == true
+    ((-1...1) === 10.5).should == false
+    ((-10..-2) === -2.5).should == true
+    (('C'..'X') === 'M').should == true
+    (('C'..'X') === 'A').should == false
+    (('B'...'W') === 'W').should == false
+    (('B'...'W') === 'Q').should == true
+    ((0.5..2.4) === 2).should == true
+    ((0.5..2.4) === 2.5).should == false
+    ((0.5...2.4) === 2.4).should == true
+    ((0.5...2.4) === 2.4).should == false
+  end
+end

data/test/core/range/end_spec.rb

@@ -0,0 +1,9 @@
+describe "Range#end" do
+  it "end returns the last element of self" do
+    (-1..1).end.should == 1
+    (0..1).end.should == 1
+    ("A".."Q").end.should == "Q"
+    ("A"..."Q").end.should == "Q"
+    (0.5..2.4).end.should == 2.4
+  end
+end

data/test/core/string/capitalize_spec.rb

@@ -0,0 +1,10 @@
+describe "String#capitalize" do
+  it "returns a copy of self with the first character converted to uppercase and the remainder to lowercase" do
+    "".capitalize.should == ""
+    "h".capitalize.should == "H"
+    "H".capitalize.should == "H"
+    "hello".capitalize.should == "Hello"
+    "HELLO".capitalize.should == "Hello"
+    "123ABC".capitalize.should == "123abc"
+  end
+end

data/test/core/string/casecmp_spec.rb

@@ -0,0 +1,16 @@
+describe "String#casecmp" do
+  it "returns -1 when less than other" do
+    "a".casecmp("b").should == -1
+    "A".casecmp("b").should == -1
+  end
+
+  it "returns 0 when equal to other" do
+    "a".casecmp("a").should == 0
+    "A".casecmp("a").should == 0
+  end
+
+  it "returns 1 when greater than other" do
+    "b".casecmp("a").should == 1
+    "B".casecmp("a").should == 1
+  end
+end

data/test/core/string/chomp_spec.rb

@@ -0,0 +1,43 @@
+describe "String#chomp with separator" do
+  it "returns a new string with the given record separator removed" do
+    "hello".chomp("llo").should == "he"
+    "hellollo".chomp("llo").should == "hello"
+  end
+
+  it "removes carriage return (except \\r) chars multiple times when separator is an empty string" do
+    "".chomp("").should == ""
+    "hello".chomp("").should == "hello"
+    "hello\n".chomp("").should == "hello"
+    "hello\nx".chomp("").should == "hello\nx"
+    "hello\r\n".chomp("").should == "hello"
+    "hello\r\n\r\n\n\n\r\n".chomp("").should == "hello"
+
+    "hello\r".chomp("").should == "hello\r"
+    "hello\n\r".chomp("").should == "hello\n\r"
+    "hello\r\r\r\n".chomp("").should == "hello\r\r"
+  end
+
+  it "removes carriage return chars(\\n, \\r, \\r\\n) when separator is \\n" do
+    "hello".chomp("\n").should == "hello"
+    "hello\n".chomp("\n").should == "hello"
+    "hello\r\n".chomp("\n").should == "hello"
+    "hello\n\r".chomp("\n").should == "hello\n"
+    "hello\r".chomp("\n").should == "hello"
+    "hello \n there".chomp("\n").should == "hello \n there"
+    "hello\r\n\r\n\n\n\r\n".chomp("\n").should == "hello\r\n\r\n\n\n"
+
+    "hello\n\r".chomp("\r").should == "hello\n"
+    "hello\n\r\n".chomp("\r\n").should == "hello\n"
+  end
+
+  it "returns self if the separator is nil" do
+    "hello\n\n".chomp(nil).should == "hello\n\n"
+  end
+
+  it "returns an empty string when called on an empty string" do
+    "".chomp("\n").should == ""
+    "".chomp("\r").should == ""
+    "".chomp("").should == ""
+    "".chomp(nil).should == ""
+  end
+end