kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Add a new #filter alias for #select

Browse source 
* In Enumerable, Enumerator::Lazy, Array, Hash and Set
  [Feature #13784] [ruby-core:82285]
* Share specs for the various #select#select! methods and
  reuse them for #filter/#filter!.
* Add corresponding filter tests for select tests.
* Update NEWS.

[Fix GH-1824]

From: Alexander Patrick <adp90@case.edu>

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@62575 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
eregon 2018-02-25 13:52:07 +00:00
parent d1ea2f9d8f
commit b1a8c64483
24 changed files with 406 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
NEWS
View file

@ -20,6 +20,13 @@ with all sufficient information, see the ChangeLog file or Redmine
=== Core classes updates (outstanding ones only)
* Array
* Aliased methods:
* Array#filter is a new alias for Array#select [Feature #13784]
* Array#filter! is a new alias for Array#select! [Feature #13784]
* Binding
* New methods:
@ -40,6 +47,25 @@ with all sufficient information, see the ChangeLog file or Redmine
* added Dir#each_child and Dir#children instance methods. [Feature #13969]
* Enumerable
* Aliased methods:
* Enumerable#filter is a new alias for Enumerable#select [Feature #13784]
* Enumerator::Lazy
* Aliased methods:
* Enumerator::Lazy#filter is a new alias for Enumerator::Lazy#select [Feature #13784]
* Hash
* Aliased methods:
* Hash#filter is a new alias for Hash#select [Feature #13784]
* Hash#filter! is a new alias for Hash#select! [Feature #13784]
* Kernel
* Kernel.#system takes :exception option to raise an exception on
@ -80,6 +106,12 @@ with all sufficient information, see the ChangeLog file or Redmine
* Matrix#antisymmetric?
* Set
* Aliased methods:
* Set#filter! is a new alias for Set#select! [Feature #13784]
=== Compatibility issues (excluding feature bug fixes)
=== Stdlib compatibility issues (excluding feature bug fixes)

2
array.c
View file

@ -6298,6 +6298,8 @@ Init_Array(void)
rb_define_method(rb_cArray, "map!", rb_ary_collect_bang, 0);
rb_define_method(rb_cArray, "select", rb_ary_select, 0);
rb_define_method(rb_cArray, "select!", rb_ary_select_bang, 0);
rb_define_method(rb_cArray, "filter", rb_ary_select, 0);
rb_define_method(rb_cArray, "filter!", rb_ary_select_bang, 0);
rb_define_method(rb_cArray, "keep_if", rb_ary_keep_if, 0);
rb_define_method(rb_cArray, "values_at", rb_ary_values_at, -1);
rb_define_method(rb_cArray, "delete", rb_ary_delete, 1);

5
enum.c
View file

@ -388,8 +388,10 @@ enum_size_over_p(VALUE obj, long n)
* call-seq:
* enum.find_all { |obj| block } -> array
* enum.select { |obj| block } -> array
* enum.filter { |obj| block } -> array
* enum.find_all -> an_enumerator
* enum.select -> an_enumerator
* enum.filter -> an_enumerator
*
* Returns an array containing all elements of +enum+
* for which the given +block+ returns a true value.
@ -401,6 +403,8 @@ enum_size_over_p(VALUE obj, long n)
*
* [1,2,3,4,5].select { |num| num.even? } #=> [2, 4]
*
* [:foo, :bar].filter { |x| x == :foo } #=> [:foo]
*
* See also Enumerable#reject.
*/
@ -3994,6 +3998,7 @@ Init_Enumerable(void)
rb_define_method(rb_mEnumerable, "find_index", enum_find_index, -1);
rb_define_method(rb_mEnumerable, "find_all", enum_find_all, 0);
rb_define_method(rb_mEnumerable, "select", enum_find_all, 0);
rb_define_method(rb_mEnumerable, "filter", enum_find_all, 0);
rb_define_method(rb_mEnumerable, "reject", enum_reject, 0);
rb_define_method(rb_mEnumerable, "collect", enum_collect, 0);
rb_define_method(rb_mEnumerable, "map", enum_collect, 0);

1
enumerator.c
View file

@ -2377,6 +2377,7 @@ InitVM_Enumerator(void)
rb_define_method(rb_cLazy, "collect_concat", lazy_flat_map, 0);
rb_define_method(rb_cLazy, "select", lazy_select, 0);
rb_define_method(rb_cLazy, "find_all", lazy_select, 0);
rb_define_method(rb_cLazy, "filter", lazy_select, 0);
rb_define_method(rb_cLazy, "reject", lazy_reject, 0);
rb_define_method(rb_cLazy, "grep", lazy_grep, 1);
rb_define_method(rb_cLazy, "grep_v", lazy_grep_v, 1);

4
hash.c
View file

@ -4690,6 +4690,8 @@ Init_Hash(void)
rb_define_method(rb_cHash, "keep_if", rb_hash_keep_if, 0);
rb_define_method(rb_cHash, "select", rb_hash_select, 0);
rb_define_method(rb_cHash, "select!", rb_hash_select_bang, 0);
rb_define_method(rb_cHash, "filter", rb_hash_select, 0);
rb_define_method(rb_cHash, "filter!", rb_hash_select_bang, 0);
rb_define_method(rb_cHash, "reject", rb_hash_reject, 0);
rb_define_method(rb_cHash, "reject!", rb_hash_reject_bang, 0);
rb_define_method(rb_cHash, "slice", rb_hash_slice, -1);
@ -4752,6 +4754,8 @@ Init_Hash(void)
rb_define_singleton_method(envtbl, "reject!", env_reject_bang, 0);
rb_define_singleton_method(envtbl, "select", env_select, 0);
rb_define_singleton_method(envtbl, "select!", env_select_bang, 0);
rb_define_singleton_method(envtbl, "filter", env_select, 0);
rb_define_singleton_method(envtbl, "filter!", env_select_bang, 0);
rb_define_singleton_method(envtbl, "shift", env_shift, 0);
rb_define_singleton_method(envtbl, "invert", env_invert, 0);
rb_define_singleton_method(envtbl, "replace", env_replace, 1);

3
lib/set.rb
View file

@ -424,6 +424,9 @@ class Set
self if size != n
end
# Equivalent to Set#select!
alias filter! select!
# Merges the elements of the given enumerable object to the set and
# returns self.
def merge(enum)

14
spec/ruby/core/array/filter_spec.rb Normal file
View file

@ -0,0 +1,14 @@
require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../shared/select', __FILE__)
describe "Array#filter" do
it_behaves_like :array_select, :filter
end
describe "Array#filter!" do
it "returns nil if no changes were made in the array" do
[1, 2, 3].filter! { true }.should be_nil
end
it_behaves_like :keep_if, :filter!
end

26
spec/ruby/core/array/select_spec.rb
View file

@ -1,30 +1,8 @@
require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/classes', __FILE__)
require File.expand_path('../shared/enumeratorize', __FILE__)
require File.expand_path('../shared/keep_if', __FILE__)
require File.expand_path('../../enumerable/shared/enumeratorized', __FILE__)
require File.expand_path('../shared/select', __FILE__)
describe "Array#select" do
it_behaves_like :enumeratorize, :select
it_behaves_like :enumeratorized_with_origin_size, :select, [1,2,3]
it "returns a new array of elements for which block is true" do
[1, 3, 4, 5, 6, 9].select { |i| i % ((i + 1) / 2) == 0}.should == [1, 4, 6]
end
it "does not return subclass instance on Array subclasses" do
ArraySpecs::MyArray[1, 2, 3].select { true }.should be_an_instance_of(Array)
end
it "properly handles recursive arrays" do
empty = ArraySpecs.empty_recursive_array
empty.select { true }.should == empty
empty.select { false }.should == []
array = ArraySpecs.recursive_array
array.select { true }.should == [1, 'two', 3.0, array, array, array, array, array]
array.select { false }.should == []
end
it_behaves_like :array_select, :select
end
describe "Array#select!" do

32
spec/ruby/core/array/shared/select.rb Normal file
View file

@ -0,0 +1,32 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../../fixtures/classes', __FILE__)
require File.expand_path('../../shared/enumeratorize', __FILE__)
require File.expand_path('../../shared/keep_if', __FILE__)
require File.expand_path('../../../enumerable/shared/enumeratorized', __FILE__)
describe :array_select, shared: true do
it_should_behave_like :enumeratorize
before :each do
@object = [1,2,3]
end
it_should_behave_like :enumeratorized_with_origin_size
it "returns a new array of elements for which block is true" do
[1, 3, 4, 5, 6, 9].send(@method) { |i| i % ((i + 1) / 2) == 0}.should == [1, 4, 6]
end
it "does not return subclass instance on Array subclasses" do
ArraySpecs::MyArray[1, 2, 3].send(@method) { true }.should be_an_instance_of(Array)
end
it "properly handles recursive arrays" do
empty = ArraySpecs.empty_recursive_array
empty.send(@method) { true }.should == empty
empty.send(@method) { false }.should == []
array = ArraySpecs.recursive_array
array.send(@method) { true }.should == [1, 'two', 3.0, array, array, array, array, array]
array.send(@method) { false }.should == []
end
end

7
spec/ruby/core/enumerable/filter_spec.rb Normal file
View file

@ -0,0 +1,7 @@
require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/classes', __FILE__)
require File.expand_path('../shared/find_all', __FILE__)
describe "Enumerable#filter" do
it_behaves_like(:enumerable_find_all , :filter)
end

10
spec/ruby/core/hash/filter_spec.rb Normal file
View file

@ -0,0 +1,10 @@
require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../shared/select', __FILE__)
describe "Hash#filter" do
it_behaves_like :hash_select, :filter
end
describe "Hash#filter!" do
it_behaves_like :hash_select!, :filter!
end

79
spec/ruby/core/hash/select_spec.rb
View file

@ -1,83 +1,10 @@
require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../fixtures/classes', __FILE__)
require File.expand_path('../shared/iteration', __FILE__)
require File.expand_path('../../enumerable/shared/enumeratorized', __FILE__)
require File.expand_path('../shared/select', __FILE__)
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.sort.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_an_instance_of(Hash)
a_pairs.sort.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.dup.select { |*pair| select_pairs << pair }
h.reject { |*pair| reject_pairs << pair }
select_pairs.should == reject_pairs
end
it "returns an Enumerator when called on a non-empty hash without a block" do
@hsh.select.should be_an_instance_of(Enumerator)
end
it "returns an Enumerator when called on an empty hash without a block" do
@empty.select.should be_an_instance_of(Enumerator)
end
it_behaves_like :hash_iteration_no_block, :select
it_behaves_like :enumeratorized_with_origin_size, :select, { 1 => 2, 3 => 4, 5 => 6 }
it_behaves_like :hash_select, :select
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
h = { a: 2 }
h.select! { |k,v| v <= 1 }.should equal h
h = { 1 => 2, 3 => 4 }
all_args_select = []
h.dup.select! { |*args| all_args_select << args }
all_args_select.should == [[1, 2], [3, 4]]
end
it "removes all entries if the block is false" do
h = { a: 1, b: 2, c: 3 }
h.select! { |k,v| false }.should equal(h)
h.should == {}
end
it "returns nil if no changes were made" do
{ a: 1 }.select! { |k,v| v <= 1 }.should == nil
end
it "raises a #{frozen_error_class} if called on an empty frozen instance" do
lambda { HashSpecs.empty_frozen_hash.select! { false } }.should raise_error(frozen_error_class)
end
it "raises a #{frozen_error_class} if called on a frozen instance that would not be modified" do
lambda { HashSpecs.frozen_hash.select! { true } }.should raise_error(frozen_error_class)
end
it_behaves_like :hash_iteration_no_block, :select!
it_behaves_like :enumeratorized_with_origin_size, :select!, { 1 => 2, 3 => 4, 5 => 6 }
it_behaves_like :hash_select!, :select!
end

91
spec/ruby/core/hash/shared/select.rb Normal file
View file

@ -0,0 +1,91 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../../fixtures/classes', __FILE__)
require File.expand_path('../../shared/iteration', __FILE__)
require File.expand_path('../../../enumerable/shared/enumeratorized', __FILE__)
describe :hash_select, shared: true 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 }.send(@method) { |*args| all_args << args }
all_args.sort.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 }.send(@method) { |k,v| v % 2 == 0 }
a_pairs.should be_an_instance_of(Hash)
a_pairs.sort.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.dup.send(@method) { |*pair| select_pairs << pair }
h.reject { |*pair| reject_pairs << pair }
select_pairs.should == reject_pairs
end
it "returns an Enumerator when called on a non-empty hash without a block" do
@hsh.send(@method).should be_an_instance_of(Enumerator)
end
it "returns an Enumerator when called on an empty hash without a block" do
@empty.send(@method).should be_an_instance_of(Enumerator)
end
it_should_behave_like :hash_iteration_no_block
before :each do
@object = { 1 => 2, 3 => 4, 5 => 6 }
end
it_should_behave_like :enumeratorized_with_origin_size
end
describe :hash_select!, shared: true do
before :each do
@hsh = { 1 => 2, 3 => 4, 5 => 6 }
@empty = {}
end
it "is equivalent to keep_if if changes are made" do
h = { a: 2 }
h.send(@method) { |k,v| v <= 1 }.should equal h
h = { 1 => 2, 3 => 4 }
all_args_select = []
h.dup.send(@method) { |*args| all_args_select << args }
all_args_select.should == [[1, 2], [3, 4]]
end
it "removes all entries if the block is false" do
h = { a: 1, b: 2, c: 3 }
h.send(@method) { |k,v| false }.should equal(h)
h.should == {}
end
it "returns nil if no changes were made" do
{ a: 1 }.send(@method) { |k,v| v <= 1 }.should == nil
end
it "raises a #{frozen_error_class} if called on an empty frozen instance" do
lambda { HashSpecs.empty_frozen_hash.send(@method) { false } }.should raise_error(frozen_error_class)
end
it "raises a #{frozen_error_class} if called on a frozen instance that would not be modified" do
lambda { HashSpecs.frozen_hash.send(@method) { true } }.should raise_error(frozen_error_class)
end
it_should_behave_like :hash_iteration_no_block
before :each do
@object = { 1 => 2, 3 => 4, 5 => 6 }
end
it_should_behave_like :enumeratorized_with_origin_size
end

6
spec/ruby/library/set/filter_spec.rb Normal file
View file

@ -0,0 +1,6 @@
require File.expand_path('../../../spec_helper', __FILE__)
require File.expand_path('../shared/select', __FILE__)
describe "Set#filter!" do
it_behaves_like :set_select_bang, :filter!
end

40
spec/ruby/library/set/select_spec.rb
View file

@ -1,42 +1,6 @@
require File.expand_path('../../../spec_helper', __FILE__)
require 'set'
require File.expand_path('../shared/select', __FILE__)
describe "Set#select!" do
before :each do
@set = Set["one", "two", "three"]
end
it "yields every element of self" do
ret = []
@set.select! { |x| ret << x }
ret.sort.should == ["one", "two", "three"].sort
end
it "keeps every element from self for which the passed block returns true" do
@set.select! { |x| x.size != 3 }
@set.size.should eql(1)
@set.should_not include("one")
@set.should_not include("two")
@set.should include("three")
end
it "returns self when self was modified" do
@set.select! { false }.should equal(@set)
end
it "returns nil when self was not modified" do
@set.select! { true }.should be_nil
end
it "returns an Enumerator when passed no block" do
enum = @set.select!
enum.should be_an_instance_of(Enumerator)
enum.each { |x| x.size != 3 }
@set.should_not include("one")
@set.should_not include("two")
@set.should include("three")
end
it_behaves_like :set_select_bang, :select!
end

42
spec/ruby/library/set/shared/select.rb Normal file
View file

@ -0,0 +1,42 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require 'set'
describe :set_select_bang, shared: true do
before :each do
@set = Set["one", "two", "three"]
end
it "yields every element of self" do
ret = []
@set.send(@method) { |x| ret << x }
ret.sort.should == ["one", "two", "three"].sort
end
it "keeps every element from self for which the passed block returns true" do
@set.send(@method) { |x| x.size != 3 }
@set.size.should eql(1)
@set.should_not include("one")
@set.should_not include("two")
@set.should include("three")
end
it "returns self when self was modified" do
@set.send(@method) { false }.should equal(@set)
end
it "returns nil when self was not modified" do
@set.send(@method) { true }.should be_nil
end
it "returns an Enumerator when passed no block" do
enum = @set.send(@method)
enum.should be_an_instance_of(Enumerator)
enum.each { |x| x.size != 3 }
@set.should_not include("one")
@set.should_not include("two")
@set.should include("three")
end
end

7
spec/ruby/library/set/sortedset/filter_spec.rb Normal file
View file

@ -0,0 +1,7 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../shared/select', __FILE__)
require 'set'
describe "SortedSet#filter!" do
it_behaves_like :sorted_set_select_bang, :filter!
end

32
spec/ruby/library/set/sortedset/select_spec.rb
View file

@ -1,35 +1,7 @@
require File.expand_path('../../../../spec_helper', __FILE__)
require File.expand_path('../shared/select', __FILE__)
require 'set'
describe "SortedSet#select!" do
before :each do
@set = SortedSet["one", "two", "three"]
end
it "yields each Object in self in sorted order" do
res = []
@set.select! { |x| res << x }
res.should == ["one", "two", "three"].sort
end
it "keeps every element from self for which the passed block returns true" do
@set.select! { |x| x.size != 3 }
@set.to_a.should == ["three"]
end
it "returns self when self was modified" do
@set.select! { false }.should equal(@set)
end
it "returns nil when self was not modified" do
@set.select! { true }.should be_nil
end
it "returns an Enumerator when passed no block" do
enum = @set.select!
enum.should be_an_instance_of(Enumerator)
enum.each { |x| x.size != 3 }
@set.to_a.should == ["three"]
end
it_behaves_like :sorted_set_select_bang, :select!
end

35
spec/ruby/library/set/sortedset/shared/select.rb Normal file
View file

@ -0,0 +1,35 @@
require File.expand_path('../../../../../spec_helper', __FILE__)
require 'set'
describe :sorted_set_select_bang, shared: true do
before :each do
@set = SortedSet["one", "two", "three"]
end
it "yields each Object in self in sorted order" do
res = []
@set.send(@method) { |x| res << x }
res.should == ["one", "two", "three"].sort
end
it "keeps every element from self for which the passed block returns true" do
@set.send(@method) { |x| x.size != 3 }
@set.to_a.should == ["three"]
end
it "returns self when self was modified" do
@set.send(@method) { false }.should equal(@set)
end
it "returns nil when self was not modified" do
@set.send(@method) { true }.should be_nil
end
it "returns an Enumerator when passed no block" do
enum = @set.send(@method)
enum.should be_an_instance_of(Enumerator)
enum.each { |x| x.size != 3 }
@set.to_a.should == ["three"]
end
end

20
test/ruby/test_array.rb
View file

@ -170,6 +170,7 @@ class TestArray < Test::Unit::TestCase
def test_find_all_0
assert_respond_to([], :find_all)
assert_respond_to([], :select) # Alias
assert_respond_to([], :filter) # Alias
assert_equal([], [].find_all{ |obj| obj == "foo"})
x = ["foo", "bar", "baz", "baz", 1, 2, 3, 3, 4]
@ -2301,6 +2302,25 @@ class TestArray < Test::Unit::TestCase
assert_equal(@cls[4, 5], a)
end
def test_filter
assert_equal([0, 2], [0, 1, 2, 3].filter {|x| x % 2 == 0 })
end
# alias for select!
def test_filter!
a = @cls[ 1, 2, 3, 4, 5 ]
assert_equal(nil, a.filter! { true })
assert_equal(@cls[1, 2, 3, 4, 5], a)
a = @cls[ 1, 2, 3, 4, 5 ]
assert_equal(a, a.filter! { false })
assert_equal(@cls[], a)
a = @cls[ 1, 2, 3, 4, 5 ]
assert_equal(a, a.filter! { |i| i > 3 })
assert_equal(@cls[4, 5], a)
end
def test_delete2
a = [0] * 1024 + [1] + [0] * 1024
a.delete(0)

6
test/ruby/test_enumerator.rb
View file

@ -505,7 +505,7 @@ class TestEnumerator < Test::Unit::TestCase
def test_size_for_enum_created_from_array
arr = %w[hello world]
%i[each each_with_index reverse_each sort_by! sort_by map map!
keep_if reject! reject select! select delete_if].each do |method|
keep_if reject! reject select! select filter! filter delete_if].each do |method|
assert_equal arr.size, arr.send(method).size
end
end
@ -522,7 +522,7 @@ class TestEnumerator < Test::Unit::TestCase
def test_size_for_enum_created_from_hash
h = {a: 1, b: 2, c: 3}
methods = %i[delete_if reject reject! select select! keep_if each each_key each_pair]
methods = %i[delete_if reject reject! select select! filter filter! keep_if each each_key each_pair]
enums = methods.map {|method| h.send(method)}
s = enums.group_by(&:size)
assert_equal([3], s.keys, ->{s.reject!{|k| k==3}.inspect})
@ -532,7 +532,7 @@ class TestEnumerator < Test::Unit::TestCase
end
def test_size_for_enum_created_from_env
%i[each_pair reject! delete_if select select! keep_if].each do |method|
%i[each_pair reject! delete_if select select! filter filter! keep_if].each do |method|
assert_equal ENV.size, ENV.send(method).size
end
end

27
test/ruby/test_env.rb
View file

@ -222,6 +222,18 @@ class TestEnv < Test::Unit::TestCase
assert_nil(ENV.select! {|k, v| IGNORE_CASE ? k.upcase != "TEST" : k != "test" })
end
def test_filter_bang
h1 = {}
ENV.each_pair {|k, v| h1[k] = v }
ENV["test"] = "foo"
ENV.filter! {|k, v| IGNORE_CASE ? k.upcase != "TEST" : k != "test" }
h2 = {}
ENV.each_pair {|k, v| h2[k] = v }
assert_equal(h1, h2)
assert_nil(ENV.filter! {|k, v| IGNORE_CASE ? k.upcase != "TEST" : k != "test" })
end
def test_keep_if
h1 = {}
ENV.each_pair {|k, v| h1[k] = v }
@ -254,6 +266,21 @@ class TestEnv < Test::Unit::TestCase
end
end
def test_filter
ENV["test"] = "foo"
h = ENV.filter {|k| IGNORE_CASE ? k.upcase == "TEST" : k == "test" }
assert_equal(1, h.size)
k = h.keys.first
v = h.values.first
if IGNORE_CASE
assert_equal("TEST", k.upcase)
assert_equal("FOO", v.upcase)
else
assert_equal("test", k)
assert_equal("foo", v)
end
end
def test_clear
ENV.clear
assert_equal(0, ENV.size)

38
test/ruby/test_hash.rb
View file

@ -1017,6 +1017,44 @@ class TestHash < Test::Unit::TestCase
assert_equal({}, {}.slice)
end
def test_filter
assert_equal({3=>4,5=>6}, @cls[1=>2,3=>4,5=>6].filter {|k, v| k + v >= 7 })
base = @cls[ 1 => 'one', '2' => false, true => 'true', 'cat' => 99 ]
h1 = @cls[ '2' => false, 'cat' => 99 ]
h2 = @cls[ 1 => 'one', true => 'true' ]
h3 = @cls[ 1 => 'one', true => 'true', 'cat' => 99 ]
h = base.dup
assert_equal(h, h.filter { true })
assert_equal(@cls[], h.filter { false })
h = base.dup
assert_equal(h1, h.filter {|k,v| k.instance_of?(String) })
assert_equal(h2, h.filter {|k,v| v.instance_of?(String) })
assert_equal(h3, h.filter {|k,v| v })
assert_equal(base, h)
h.instance_variable_set(:@foo, :foo)
h.default = 42
h.taint
h = h.filter {true}
assert_instance_of(Hash, h)
assert_not_predicate(h, :tainted?)
assert_nil(h.default)
assert_not_send([h, :instance_variable_defined?, :@foo])
end
def test_filter!
h = @cls[1=>2,3=>4,5=>6]
assert_equal(h, h.filter! {|k, v| k + v >= 7 })
assert_equal({3=>4,5=>6}, h)
h = @cls[1=>2,3=>4,5=>6]
assert_equal(nil, h.filter!{true})
end
def test_clear2
assert_equal({}, @cls[1=>2,3=>4,5=>6].clear)
h = @cls[1=>2,3=>4,5=>6]

18
test/test_set.rb
View file

@ -545,6 +545,24 @@ class TC_Set < Test::Unit::TestCase
assert_equal(Set.new(1..10), set)
end
def test_filter!
set = Set.new(1..10)
ret = set.filter! { |i| i <= 10 }
assert_equal(nil, ret)
assert_equal(Set.new(1..10), set)
set = Set.new(1..10)
ret = set.filter! { |i| i % 3 != 0 }
assert_same(set, ret)
assert_equal(Set[1,2,4,5,7,8,10], set)
set = Set.new(1..10)
enum = set.filter!
assert_equal(set.size, enum.size)
assert_equal(nil, enum.each { |i| i <= 10 })
assert_equal(Set.new(1..10), set)
end
def test_merge
set = Set[1,2,3]