0s autopkgtest [07:04:34]: starting date and time: 2026-02-10 07:04:34+0000 0s autopkgtest [07:04:34]: git checkout: 508d4a25 a-v-ssh wait_for_ssh: demote "ssh connection failed" to a debug message 0s autopkgtest [07:04:34]: host juju-7f2275-prod-proposed-migration-environment-9; command line: /home/ubuntu/autopkgtest/runner/autopkgtest --output-dir /tmp/autopkgtest-work._z_bcgqg/out --timeout-copy=6000 --setup-commands 'ln -s /dev/null /etc/systemd/system/bluetooth.service; printf "http_proxy=http://squid.internal:3128\nhttps_proxy=http://squid.internal:3128\nno_proxy=127.0.0.1,127.0.1.1,localhost,localdomain,internal,login.ubuntu.com,archive.ubuntu.com,ports.ubuntu.com,security.ubuntu.com,ddebs.ubuntu.com,changelogs.ubuntu.com,keyserver.ubuntu.com,launchpadlibrarian.net,launchpadcontent.net,launchpad.net,keystone.ps5.canonical.com,objectstorage.prodstack5.canonical.com,radosgw.ps5.canonical.com\n" >> /etc/environment' --apt-pocket=proposed=src:ruby-concurrent --apt-upgrade ruby-hamster --timeout-short=300 --timeout-copy=20000 --timeout-build=20000 --env=ADT_TEST_TRIGGERS=ruby-concurrent/1.3.6-1 -- lxd -r lxd-armhf-10.145.243.221 lxd-armhf-10.145.243.221:autopkgtest/ubuntu/resolute/armhf 28s autopkgtest [07:05:02]: testbed dpkg architecture: armhf 31s autopkgtest [07:05:05]: testbed apt version: 3.1.15 35s autopkgtest [07:05:09]: @@@@@@@@@@@@@@@@@@@@ test bed setup 37s autopkgtest [07:05:11]: testbed release detected to be: None 44s autopkgtest [07:05:18]: updating testbed package index (apt update) 47s Get:1 http://ftpmaster.internal/ubuntu resolute-proposed InRelease [124 kB] 47s Get:2 http://ftpmaster.internal/ubuntu resolute InRelease [124 kB] 47s Hit:3 http://ftpmaster.internal/ubuntu resolute-updates InRelease 47s Hit:4 http://ftpmaster.internal/ubuntu resolute-security InRelease 48s Get:5 http://ftpmaster.internal/ubuntu resolute-proposed/main Sources [178 kB] 48s Get:6 http://ftpmaster.internal/ubuntu resolute-proposed/multiverse Sources [31.1 kB] 48s Get:7 http://ftpmaster.internal/ubuntu resolute-proposed/universe Sources [1727 kB] 51s Get:8 http://ftpmaster.internal/ubuntu resolute-proposed/main armhf Packages [249 kB] 51s Get:9 http://ftpmaster.internal/ubuntu resolute-proposed/universe armhf Packages [1556 kB] 53s Get:10 http://ftpmaster.internal/ubuntu resolute-proposed/multiverse armhf Packages [8156 B] 53s Get:11 http://ftpmaster.internal/ubuntu resolute/universe Sources [21.3 MB] 84s Get:12 http://ftpmaster.internal/ubuntu resolute/main Sources [1404 kB] 86s Get:13 http://ftpmaster.internal/ubuntu resolute/main armhf Packages [1386 kB] 88s Get:14 http://ftpmaster.internal/ubuntu resolute/universe armhf Packages [15.1 MB] 109s Fetched 43.2 MB in 1min 3s (685 kB/s) 111s Reading package lists... 117s autopkgtest [07:06:31]: upgrading testbed (apt dist-upgrade and autopurge) 119s Reading package lists... 119s Building dependency tree... 119s Reading state information... 120s Calculating upgrade... 121s The following packages will be upgraded: 121s libbrotli1 121s 1 upgraded, 0 newly installed, 0 to remove and 0 not upgraded. 121s Need to get 318 kB of archives. 121s After this operation, 0 B of additional disk space will be used. 121s Get:1 http://ftpmaster.internal/ubuntu resolute/main armhf libbrotli1 armhf 1.2.0-3 [318 kB] 122s Fetched 318 kB in 1s (529 kB/s) 122s (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 68691 files and directories currently installed.) 122s Preparing to unpack .../libbrotli1_1.2.0-3_armhf.deb ... 122s Unpacking libbrotli1:armhf (1.2.0-3) over (1.1.0-2build6) ... 122s Setting up libbrotli1:armhf (1.2.0-3) ... 122s Processing triggers for libc-bin (2.42-2ubuntu4) ... 125s Reading package lists... 126s Building dependency tree... 126s Reading state information... 126s Solving dependencies... 127s 0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded. 129s autopkgtest [07:06:43]: rebooting testbed after setup commands that affected boot 174s autopkgtest [07:07:28]: testbed running kernel: Linux 6.8.0-87-generic #88~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue Oct 14 14:00:09 UTC 2 203s autopkgtest [07:07:57]: @@@@@@@@@@@@@@@@@@@@ apt-source ruby-hamster 216s Get:1 http://ftpmaster.internal/ubuntu resolute/universe ruby-hamster 3.0.0-4 (dsc) [1465 B] 216s Get:2 http://ftpmaster.internal/ubuntu resolute/universe ruby-hamster 3.0.0-4 (tar) [129 kB] 216s Get:3 http://ftpmaster.internal/ubuntu resolute/universe ruby-hamster 3.0.0-4 (diff) [4880 B] 216s gpgv: Signature made Wed Jan 26 11:16:04 2022 UTC 216s gpgv: using EDDSA key 84CFFDC21520F88306EC29D152699AB63F9F2BC3 216s gpgv: Can't check signature: No public key 216s dpkg-source: warning: cannot verify inline signature for ./ruby-hamster_3.0.0-4.dsc: no acceptable signature found 216s autopkgtest [07:08:10]: testing package ruby-hamster version 3.0.0-4 218s autopkgtest [07:08:12]: build not needed 221s autopkgtest [07:08:15]: test gem2deb-test-runner: preparing testbed 223s Reading package lists... 223s Building dependency tree... 223s Reading state information... 223s Solving dependencies... 224s The following NEW packages will be installed: 224s gem2deb-test-runner libruby libruby3.3 pry rake ruby ruby-coderay 224s ruby-concurrent ruby-csv ruby-did-you-mean ruby-diff-lcs ruby-hamster 224s ruby-method-source ruby-minitest ruby-net-telnet ruby-power-assert 224s ruby-rbtree ruby-rspec ruby-rspec-core ruby-rspec-expectations 224s ruby-rspec-mocks ruby-rspec-support ruby-ruby2-keywords ruby-rubygems 224s ruby-sorted-set ruby-test-unit ruby-webrick ruby-xmlrpc ruby3.3 224s rubygems-integration 225s 0 upgraded, 30 newly installed, 0 to remove and 0 not upgraded. 225s Need to get 7305 kB of archives. 225s After this operation, 39.9 MB of additional disk space will be used. 225s Get:1 http://ftpmaster.internal/ubuntu resolute/main armhf rubygems-integration all 1.19build1 [5666 B] 225s Get:2 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-csv all 3.3.4-1 [43.0 kB] 225s Get:3 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-did-you-mean all 1.6.3-2build1 [14.9 kB] 225s Get:4 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-net-telnet all 0.2.0-1build1 [13.5 kB] 225s Get:5 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-ruby2-keywords all 0.0.5-1build1 [4398 B] 225s Get:6 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-webrick all 1.9.1-1build1 [60.9 kB] 225s Get:7 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-xmlrpc all 0.3.3-2build1 [24.9 kB] 225s Get:8 http://ftpmaster.internal/ubuntu resolute/main armhf libruby3.3 armhf 3.3.8-2ubuntu2 [5595 kB] 231s Get:9 http://ftpmaster.internal/ubuntu resolute/main armhf ruby3.3 armhf 3.3.8-2ubuntu2 [59.0 kB] 231s Get:10 http://ftpmaster.internal/ubuntu resolute/main armhf libruby armhf 1:3.3 [5162 B] 231s Get:11 http://ftpmaster.internal/ubuntu resolute/main armhf ruby-rubygems all 3.6.7-2ubuntu2 [332 kB] 232s Get:12 http://ftpmaster.internal/ubuntu resolute/main armhf ruby armhf 1:3.3 [3670 B] 232s Get:13 http://ftpmaster.internal/ubuntu resolute/main armhf rake all 13.2.1-1build1 [45.9 kB] 232s Get:14 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-minitest all 5.26.1-1 [49.3 kB] 232s Get:15 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-power-assert all 3.0.1-1 [11.4 kB] 232s Get:16 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-test-unit all 3.6.2-1 [67.0 kB] 232s Get:17 http://ftpmaster.internal/ubuntu resolute/universe armhf gem2deb-test-runner armhf 2.2.5 [18.3 kB] 232s Get:18 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-coderay all 1.1.3-8build1 [78.4 kB] 232s Get:19 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-method-source all 1.1.0-1 [8502 B] 232s Get:20 http://ftpmaster.internal/ubuntu resolute/universe armhf pry all 0.15.2-1 [122 kB] 232s Get:21 http://ftpmaster.internal/ubuntu resolute-proposed/universe armhf ruby-concurrent all 1.3.6-1 [284 kB] 232s Get:22 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-diff-lcs all 1.5.1-1 [22.8 kB] 232s Get:23 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-hamster all 3.0.0-4 [43.0 kB] 232s Get:24 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rbtree armhf 0.4.6-1build3 [20.5 kB] 233s Get:25 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-support all 3.13.0c0e0m0s1-2 [29.2 kB] 233s Get:26 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-core all 3.13.0c0e0m0s1-2 [164 kB] 233s Get:27 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-expectations all 3.13.0c0e0m0s1-2 [89.8 kB] 233s Get:28 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec-mocks all 3.13.0c0e0m0s1-2 [81.0 kB] 233s Get:29 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-rspec all 3.13.0c0e0m0s1-2 [3500 B] 233s Get:30 http://ftpmaster.internal/ubuntu resolute/universe armhf ruby-sorted-set all 1.0.3-3 [4258 B] 234s Fetched 7305 kB in 9s (833 kB/s) 234s Selecting previously unselected package rubygems-integration. 234s (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 68691 files and directories currently installed.) 234s Preparing to unpack .../00-rubygems-integration_1.19build1_all.deb ... 234s Unpacking rubygems-integration (1.19build1) ... 234s Selecting previously unselected package ruby-csv. 234s Preparing to unpack .../01-ruby-csv_3.3.4-1_all.deb ... 234s Unpacking ruby-csv (3.3.4-1) ... 234s Selecting previously unselected package ruby-did-you-mean. 234s Preparing to unpack .../02-ruby-did-you-mean_1.6.3-2build1_all.deb ... 234s Unpacking ruby-did-you-mean (1.6.3-2build1) ... 234s Selecting previously unselected package ruby-net-telnet. 234s Preparing to unpack .../03-ruby-net-telnet_0.2.0-1build1_all.deb ... 234s Unpacking ruby-net-telnet (0.2.0-1build1) ... 234s Selecting previously unselected package ruby-ruby2-keywords. 234s Preparing to unpack .../04-ruby-ruby2-keywords_0.0.5-1build1_all.deb ... 234s Unpacking ruby-ruby2-keywords (0.0.5-1build1) ... 234s Selecting previously unselected package ruby-webrick. 234s Preparing to unpack .../05-ruby-webrick_1.9.1-1build1_all.deb ... 234s Unpacking ruby-webrick (1.9.1-1build1) ... 234s Selecting previously unselected package ruby-xmlrpc. 234s Preparing to unpack .../06-ruby-xmlrpc_0.3.3-2build1_all.deb ... 234s Unpacking ruby-xmlrpc (0.3.3-2build1) ... 234s Selecting previously unselected package libruby3.3:armhf. 234s Preparing to unpack .../07-libruby3.3_3.3.8-2ubuntu2_armhf.deb ... 234s Unpacking libruby3.3:armhf (3.3.8-2ubuntu2) ... 235s Selecting previously unselected package ruby3.3. 235s Preparing to unpack .../08-ruby3.3_3.3.8-2ubuntu2_armhf.deb ... 235s Unpacking ruby3.3 (3.3.8-2ubuntu2) ... 235s Selecting previously unselected package libruby:armhf. 235s Preparing to unpack .../09-libruby_1%3a3.3_armhf.deb ... 235s Unpacking libruby:armhf (1:3.3) ... 235s Selecting previously unselected package ruby-rubygems. 235s Preparing to unpack .../10-ruby-rubygems_3.6.7-2ubuntu2_all.deb ... 235s Unpacking ruby-rubygems (3.6.7-2ubuntu2) ... 235s Selecting previously unselected package ruby. 235s Preparing to unpack .../11-ruby_1%3a3.3_armhf.deb ... 235s Unpacking ruby (1:3.3) ... 235s Selecting previously unselected package rake. 235s Preparing to unpack .../12-rake_13.2.1-1build1_all.deb ... 235s Unpacking rake (13.2.1-1build1) ... 235s Selecting previously unselected package ruby-minitest. 235s Preparing to unpack .../13-ruby-minitest_5.26.1-1_all.deb ... 235s Unpacking ruby-minitest (5.26.1-1) ... 235s Selecting previously unselected package ruby-power-assert. 235s Preparing to unpack .../14-ruby-power-assert_3.0.1-1_all.deb ... 235s Unpacking ruby-power-assert (3.0.1-1) ... 235s Selecting previously unselected package ruby-test-unit. 235s Preparing to unpack .../15-ruby-test-unit_3.6.2-1_all.deb ... 235s Unpacking ruby-test-unit (3.6.2-1) ... 235s Selecting previously unselected package gem2deb-test-runner. 235s Preparing to unpack .../16-gem2deb-test-runner_2.2.5_armhf.deb ... 235s Unpacking gem2deb-test-runner (2.2.5) ... 235s Selecting previously unselected package ruby-coderay. 235s Preparing to unpack .../17-ruby-coderay_1.1.3-8build1_all.deb ... 235s Unpacking ruby-coderay (1.1.3-8build1) ... 235s Selecting previously unselected package ruby-method-source. 235s Preparing to unpack .../18-ruby-method-source_1.1.0-1_all.deb ... 235s Unpacking ruby-method-source (1.1.0-1) ... 235s Selecting previously unselected package pry. 235s Preparing to unpack .../19-pry_0.15.2-1_all.deb ... 235s Unpacking pry (0.15.2-1) ... 235s Selecting previously unselected package ruby-concurrent. 235s Preparing to unpack .../20-ruby-concurrent_1.3.6-1_all.deb ... 235s Unpacking ruby-concurrent (1.3.6-1) ... 235s Selecting previously unselected package ruby-diff-lcs. 235s Preparing to unpack .../21-ruby-diff-lcs_1.5.1-1_all.deb ... 235s Unpacking ruby-diff-lcs (1.5.1-1) ... 236s Selecting previously unselected package ruby-hamster. 236s Preparing to unpack .../22-ruby-hamster_3.0.0-4_all.deb ... 236s Unpacking ruby-hamster (3.0.0-4) ... 236s Selecting previously unselected package ruby-rbtree. 236s Preparing to unpack .../23-ruby-rbtree_0.4.6-1build3_armhf.deb ... 236s Unpacking ruby-rbtree (0.4.6-1build3) ... 236s Selecting previously unselected package ruby-rspec-support. 236s Preparing to unpack .../24-ruby-rspec-support_3.13.0c0e0m0s1-2_all.deb ... 236s Unpacking ruby-rspec-support (3.13.0c0e0m0s1-2) ... 236s Selecting previously unselected package ruby-rspec-core. 236s Preparing to unpack .../25-ruby-rspec-core_3.13.0c0e0m0s1-2_all.deb ... 236s Unpacking ruby-rspec-core (3.13.0c0e0m0s1-2) ... 236s Selecting previously unselected package ruby-rspec-expectations. 236s Preparing to unpack .../26-ruby-rspec-expectations_3.13.0c0e0m0s1-2_all.deb ... 236s Unpacking ruby-rspec-expectations (3.13.0c0e0m0s1-2) ... 236s Selecting previously unselected package ruby-rspec-mocks. 236s Preparing to unpack .../27-ruby-rspec-mocks_3.13.0c0e0m0s1-2_all.deb ... 236s Unpacking ruby-rspec-mocks (3.13.0c0e0m0s1-2) ... 236s Selecting previously unselected package ruby-rspec. 236s Preparing to unpack .../28-ruby-rspec_3.13.0c0e0m0s1-2_all.deb ... 236s Unpacking ruby-rspec (3.13.0c0e0m0s1-2) ... 236s Selecting previously unselected package ruby-sorted-set. 236s Preparing to unpack .../29-ruby-sorted-set_1.0.3-3_all.deb ... 236s Unpacking ruby-sorted-set (1.0.3-3) ... 236s Setting up ruby-ruby2-keywords (0.0.5-1build1) ... 236s Setting up ruby-power-assert (3.0.1-1) ... 236s Setting up rubygems-integration (1.19build1) ... 236s Setting up ruby-concurrent (1.3.6-1) ... 236s Setting up ruby-minitest (5.26.1-1) ... 236s Setting up ruby-method-source (1.1.0-1) ... 236s Setting up ruby-hamster (3.0.0-4) ... 236s Setting up ruby-test-unit (3.6.2-1) ... 236s Setting up ruby-net-telnet (0.2.0-1build1) ... 236s Setting up ruby-csv (3.3.4-1) ... 236s Setting up ruby-rspec-support (3.13.0c0e0m0s1-2) ... 236s Setting up ruby-webrick (1.9.1-1build1) ... 236s Setting up ruby-did-you-mean (1.6.3-2build1) ... 236s Setting up ruby-xmlrpc (0.3.3-2build1) ... 236s Setting up rake (13.2.1-1build1) ... 236s Setting up libruby3.3:armhf (3.3.8-2ubuntu2) ... 236s Setting up ruby3.3 (3.3.8-2ubuntu2) ... 236s Setting up libruby:armhf (1:3.3) ... 236s Setting up ruby (1:3.3) ... 236s Setting up ruby-rbtree (0.4.6-1build3) ... 236s Setting up ruby-coderay (1.1.3-8build1) ... 236s Setting up ruby-rspec-core (3.13.0c0e0m0s1-2) ... 236s Setting up pry (0.15.2-1) ... 236s Setting up ruby-diff-lcs (1.5.1-1) ... 236s Setting up ruby-rubygems (3.6.7-2ubuntu2) ... 236s Setting up ruby-sorted-set (1.0.3-3) ... 236s Setting up gem2deb-test-runner (2.2.5) ... 236s Setting up ruby-rspec-expectations (3.13.0c0e0m0s1-2) ... 236s Setting up ruby-rspec-mocks (3.13.0c0e0m0s1-2) ... 236s Setting up ruby-rspec (3.13.0c0e0m0s1-2) ... 236s Processing triggers for libc-bin (2.42-2ubuntu4) ... 236s Processing triggers for man-db (2.13.1-1build1) ... 245s autopkgtest [07:08:39]: test gem2deb-test-runner: gem2deb-test-runner --autopkgtest --check-dependencies 2>&1 245s autopkgtest [07:08:39]: test gem2deb-test-runner: [----------------------- 247s 247s ┌──────────────────────────────────────────────────────────────────────────────┐ 247s │ Checking Rubygems dependency resolution on ruby3.3 │ 247s └──────────────────────────────────────────────────────────────────────────────┘ 247s 247s RUBYLIB=. GEM_PATH= ruby3.3 -e gem\ \"hamster\" 247s mv lib ./.gem2deb.lib 247s mv ./.gem2deb.lib lib 247s 247s ┌──────────────────────────────────────────────────────────────────────────────┐ 247s │ Run tests for ruby3.3 from debian/ruby-tests.rake │ 247s └──────────────────────────────────────────────────────────────────────────────┘ 247s 247s RUBYLIB=. GEM_PATH= ruby3.3 -S rake --rakelibdir /gem2deb-nonexistent -f debian/ruby-tests.rake 247s mv lib ./.gem2deb.lib 248s /usr/bin/ruby3.3 -I/usr/share/rubygems-integration/all/gems/rspec-support-3.13.1/lib:/usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/lib /usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/exe/rspec --pattern ./spec/\*\*/\*_spec.rb --format documentation 250s 250s Hamster::Associable 250s #update_in 250s with one level on existing key 250s Hash passes the value to the block 250s Vector passes the value to the block 250s Hash replaces the value with the result of the block 250s Vector replaces the value with the result of the block 250s Hash should preserve the original 250s Vector should preserve the original 250s with multi-level on existing keys 250s Hash passes the value to the block 250s Vector passes the value to the block 250s Hash replaces the value with the result of the block 250s Vector replaces the value with the result of the block 250s Hash should preserve the original 250s Vector should preserve the original 250s with multi-level creating sub-hashes when keys don't exist 250s Hash passes nil to the block 250s Vector passes nil to the block 250s Hash creates subhashes on the way to set the value 250s Vector creates subhashes on the way to set the value 250s Hash with multi-level including Vector with existing keys 250s passes the value to the block 250s replaces the value with the result of the block 250s should preserve the original 250s Vector with multi-level including Hash with existing keys 250s passes the value to the block 250s replaces the value with the result of the block 250s should preserve the original 250s with empty key_path 250s Hash raises ArguemntError 250s Vector raises ArguemntError 250s 250s Array 250s #to_list 250s returns an equivalent hamster list 250s 250s Enumerable 250s #to_list 250s returns an equivalent list 250s works on Ranges 250s 250s IO 250s #to_list 250s with a File 250s returns an equivalent list 250s with a StringIO 250s returns an equivalent list 250s 250s Hamster::Deque 250s #clear 250s on [] 250s preserves the original 250s returns an empty deque 250s on ["A"] 250s preserves the original 250s returns an empty deque 250s on ["A", "B", "C"] 250s preserves the original 250s returns an empty deque 250s from a subclass 250s returns an instance of the subclass 250s 250s Hamster::Deque 250s .[] 250s with no arguments 250s always returns the same instance 250s returns an empty, frozen deque 250s with a number of items 250s always returns a different instance 250s is the same as repeatedly using #endeque 250s 250s Hamster::Deque 250s on [] 250s returns self 250s on ["A"] 250s returns self 250s on ["A", "B", "C"] 250s returns self 250s on [] 250s returns self 250s on ["A"] 250s returns self 250s on ["A", "B", "C"] 250s returns self 250s 250s Hamster::Deque 250s #dequeue 250s on [] 250s preserves the original 250s returns [] 250s on ["A"] 250s preserves the original 250s returns [] 250s on ["A", "B", "C"] 250s preserves the original 250s returns ["B", "C"] 250s on empty subclass 250s returns emtpy object of same class 250s #shift 250s on [] 250s preserves the original 250s returns [] 250s on ["A"] 250s preserves the original 250s returns [] 250s on ["A", "B", "C"] 250s preserves the original 250s returns ["B", "C"] 250s on empty subclass 250s returns emtpy object of same class 250s 250s Hamster::Deque 250s #empty? 250s on [] 250s returns true 250s on ["A"] 250s returns false 250s on ["A", "B", "C"] 250s returns false 250s after dedequeing an item from ["A", "B", "C"] 250s returns false 250s .empty 250s returns the canonical empty deque 250s from a subclass 250s returns an empty instance of the subclass 250s 250s Hamster::Deque 250s #enqueue 250s on [] with "A" 250s preserves the original 250s returns ["A"] 250s on ["A"] with "B" 250s preserves the original 250s returns ["A", "B"] 250s on ["A"] with "A" 250s preserves the original 250s returns ["A", "A"] 250s on ["A", "B", "C"] with "D" 250s preserves the original 250s returns ["A", "B", "C", "D"] 250s #push 250s on [] with "A" 250s preserves the original 250s returns ["A"] 250s on ["A"] with "B" 250s preserves the original 250s returns ["A", "B"] 250s on ["A"] with "A" 250s preserves the original 250s returns ["A", "A"] 250s on ["A", "B", "C"] with "D" 250s preserves the original 250s returns ["A", "B", "C", "D"] 250s 250s Hamster::Deque 250s #first 250s on [] 250s returns nil 250s on ["A"] 250s returns "A" 250s on ["A", "B", "C"] 250s returns "A" 250s 250s Hamster::Deque 250s #inspect 250s on [] 250s returns "Hamster::Deque[]" 250s returns a string which can be eval'd to get an equivalent object 250s on ["A"] 250s returns "Hamster::Deque[\"A\"]" 250s returns a string which can be eval'd to get an equivalent object 250s on ["A", "B", "C"] 250s returns "Hamster::Deque[\"A\", \"B\", \"C\"]" 250s returns a string which can be eval'd to get an equivalent object 250s 250s Hamster::Deque 250s #last 250s on [] 250s returns nil 250s on ["A"] 250s returns "A" 250s on ["A", "B", "C"] 250s returns "C" 250s 250s Hamster::Deque 250s #marshal_dump/#marshal_load 251s can survive dumping and loading into a new process 251s is still possible to push and pop items after loading 251s 251s Hamster::Deque 251s .new 251s accepts a single enumerable argument and creates a new deque 251s is amenable to overriding of #initialize 251s from a subclass 251s returns a frozen instance of the subclass 251s .[] 251s accepts a variable number of items and creates a new deque 251s 251s Hamster::Deque 251s #pop 251s on [] 251s preserves the original 251s returns [] 251s returns a frozen instance 251s on ["A"] 251s preserves the original 251s returns [] 251s returns a frozen instance 251s on ["A", "B", "C"] 251s preserves the original 251s returns ["A", "B"] 251s returns a frozen instance 251s on empty subclass 251s returns emtpy object of same class 251s 251s Hamster::Deque 251s #pretty_print 251s prints the whole Deque on one line if it fits 251s prints each item on its own line, if not 251s 251s Hamster::Deque 251s #push 251s pushing "A" into [] 251s preserves the original 251s returns ["A"] 251s returns a frozen instance 251s pushing "B" into ["A"] 251s preserves the original 251s returns ["A", "B"] 251s returns a frozen instance 251s pushing "D" into ["A", "B", "C"] 251s preserves the original 251s returns ["A", "B", "C", "D"] 251s returns a frozen instance 251s on a subclass 251s returns an object of same class 251s 251s Hamster::Deque 251s modification (using #push, #pop, #shift, and #unshift) 251s works when applied in many random combinations 251s 251s Hamster::Deque 251s #shift 251s on [] 251s preserves the original 251s returns [] 251s returns a frozen instance 251s on ["A"] 251s preserves the original 251s returns [] 251s returns a frozen instance 251s on ["A", "B", "C"] 251s preserves the original 251s returns ["B", "C"] 251s returns a frozen instance 251s 251s Hamster::Deque 251s #size 251s on [] 251s returns 0 251s on ["A"] 251s returns 1 251s on ["A", "B", "C"] 251s returns 3 251s #length 251s on [] 251s returns 0 251s on ["A"] 251s returns 1 251s on ["A", "B", "C"] 251s returns 3 251s 251s Hamster::Deque 251s #to_a 251s on [] 251s returns [] 251s returns a mutable array 251s on ["A"] 251s returns ["A"] 251s returns a mutable array 251s on ["A", "B", "C"] 251s returns ["A", "B", "C"] 251s returns a mutable array 251s #entries 251s on [] 251s returns [] 251s returns a mutable array 251s on ["A"] 251s returns ["A"] 251s returns a mutable array 251s on ["A", "B", "C"] 251s returns ["A", "B", "C"] 251s returns a mutable array 251s 251s Hamster::Deque 251s #to_ary 251s enables implicit conversion to 251s block parameters 251s method arguments 251s works with splat 251s 251s Hamster::Deque 251s #to_list 251s on [] 251s returns a list containing [] 251s on ["A"] 251s returns a list containing ["A"] 251s on ["A", "B", "C"] 251s returns a list containing ["A", "B", "C"] 251s after dedequeing an item from ["A", "B", "C"] 251s returns a list containing ["B", "C"] 251s 251s Hamster::Deque 251s #unshift 251s on [] with "A" 251s preserves the original 251s returns ["A"] 251s returns a frozen instance 251s on ["A"] with "B" 251s preserves the original 251s returns ["B", "A"] 251s returns a frozen instance 251s on ["A"] with "A" 251s preserves the original 251s returns ["A", "A"] 251s returns a frozen instance 251s on ["A", "B", "C"] with "D" 251s preserves the original 251s returns ["D", "A", "B", "C"] 251s returns a frozen instance 251s 251s Hamster::MutableSet 251s #add? 251s with a unique value 251s returns true 251s modifies the set to include the new value 251s with a duplicate value 251s returns false 251s preserves the original values 251s 251s Hamster::MutableSet 251s #add 251s with a unique value 251s returns self 251s modifies the original set to include new value 251s with a duplicate value 251s returns self 251s preserves the original values 251s 251s Hamster::MutableSet 251s #delete? 251s with an existing value 251s returns true 251s modifies the set to remove the value 251s with a non-existing value 251s returns false 251s preserves the original values 251s 251s Hamster::MutableSet 251s #delete 251s with an existing value 251s returns self 251s modifies the set to remove the value 251s with a non-existing value 251s returns self 251s preserves the original values 251s 251s Hamster::Hash 251s #all? 251s when empty 251s without a block 251s returns true 251s with a block 251s returns true 251s when not empty 251s without a block 251s returns true 251s with a block 251s returns true if the block always returns true 251s returns false if the block ever returns false 251s propagates an exception from the block 251s stops iterating as soon as the block returns false 251s 251s Hamster::Hash 251s #any? 251s when empty 251s with a block returns false 251s with no block returns false 251s when not empty 251s with a block 251s returns true if the block ever returns true (["A", "aye"]) 251s returns false if the block always returns false 251s returns true if the block ever returns true (["B", "bee"]) 251s returns false if the block always returns false 251s returns true if the block ever returns true (["C", "see"]) 251s returns false if the block always returns false 251s returns true if the block ever returns true ([nil, "NIL"]) 251s returns false if the block always returns false 251s propagates exceptions raised in the block 251s stops iterating as soon as the block returns true 251s with no block 251s returns true 251s 251s Hamster::Hash 251s #assoc 251s searches for a key/val pair with a given key 251s returns nil if a matching key is not found 251s returns nil even if there is a default 251s uses #== to compare keys with provided object 251s #rassoc 251s searches for a key/val pair with a given value 251s returns nil if a matching value is not found 251s returns nil even if there is a default 251s uses #== to compare values with provided object 251s 251s Hamster::Hash 251s #clear 251s maintains the default Proc, if there is one 251s on [] 251s preserves the original 251s returns an empty hash 251s on [{"A"=>"aye"}] 251s preserves the original 251s returns an empty hash 251s on [{"A"=>"aye", "B"=>"bee", "C"=>"see"}] 251s preserves the original 251s returns an empty hash 251s on a subclass 251s returns an empty instance of the subclass 251s 251s Hamster::Hash 251s .hash 251s with nothing 251s returns the canonical empty hash 251s with an implicit hash 251s is equivalent to repeatedly using #put 251s with an array of pairs 251s initializes a new Hash 251s with a Hamster::Hash 251s initializes an equivalent Hash 251s 251s Hamster::Hash 251s #dup 251s returns self 251s #clone 251s returns self 251s 251s Hamster::Hash 251s #default_proc 251s returns the default block given when the Hash was created 251s returns nil if no default block was given 251s after a key/val pair are inserted 251s doesn't change 251s after all key/val pairs are filtered out 251s doesn't change 251s after Hash is inverted 251s doesn't change 251s when a slice is taken 251s doesn't change 251s when keys are removed with #except 251s doesn't change 251s when Hash is mapped 251s doesn't change 251s when another Hash is merged in 251s doesn't change 251s 251s Hamster::Hash 251s #delete 251s with an existing key 251s preserves the original 251s returns a copy with the remaining key/value pairs 251s with a non-existing key 251s preserves the original values 251s returns self 251s when removing the last key 251s from a Hash with no default block 251s returns the canonical empty Hash 251s 251s Hamster::Hash 251s #dig 251s returns the value with one argument to dig 251s returns the value in nested hashes 251s returns nil if the key is not present 251s returns nil if you dig out the end of the hash 251s returns nil if a value does not support dig 251s returns the correct value when there is a default proc 251s 251s Hamster::Hash 251s #each 251s with a block (internal iteration) 251s returns self 251s yields all key/value pairs 251s yields key/value pairs in the same order as #each_key and #each_value 251s yields both of a pair of colliding keys 251s yields only the key to a block expecting |key,| 251s with no block 251s returns an Enumerator 251s #each_pair 251s with a block (internal iteration) 251s returns self 251s yields all key/value pairs 251s yields key/value pairs in the same order as #each_key and #each_value 251s yields both of a pair of colliding keys 251s yields only the key to a block expecting |key,| 251s with no block 251s returns an Enumerator 251s #each_key 251s yields all keys 251s with no block 251s returns an Enumerator 251s #each_value 251s yields all values 251s with no block 251s returns an Enumerator 251s 251s Hamster::Hash 251s #each_with_index 251s with a block (internal iteration) 251s returns self 251s yields all key/value pairs with numeric indexes 251s with no block 251s returns an Enumerator 251s 251s Hamster::Hash 251s #empty? 251s returns true for [] 251s returns false for [{"A"=>"aye"}] 251s returns false for [{"A"=>"aye", "B"=>"bee", "C"=>"see"}] 251s returns true for empty hashes which have a default block 251s .empty 251s returns the canonical empty Hash 251s from a subclass 251s returns an empty instance of the subclass 251s calls overridden #initialize when creating empty Hash 251s 251s Hamster::Hash 251s returns true on a large hash which is modified and then modified back again 251s #eql? 251s returns false when comparing with a standard hash 251s returns false when comparing with an arbitrary object 251s returns false when comparing with a subclass of Hamster::Hash 251s #== 251s returns true when comparing with a standard hash 251s returns false when comparing with an arbitrary object 251s returns true when comparing with a subclass of Hamster::Hash 251s #eql? 251s returns true 251s for {} and {} 251s for {} and {} 251s returns false 251s for {"A"=>"aye"} and {} 251s for {} and {"A"=>"aye"} 251s returns false 251s for {} and {"A"=>"aye"} 251s for {"A"=>"aye"} and {} 251s returns true 251s for {"A"=>"aye"} and {"A"=>"aye"} 251s for {"A"=>"aye"} and {"A"=>"aye"} 251s returns false 251s for {"A"=>"aye"} and {"B"=>"bee"} 251s for {"B"=>"bee"} and {"A"=>"aye"} 251s returns false 251s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 251s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 251s returns false 251s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 251s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 251s returns true 251s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 251s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 251s returns true 251s for {"C"=>"see", "A"=>"aye", "B"=>"bee"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 251s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"C"=>"see", "A"=>"aye", "B"=>"bee"} 251s #== 251s returns true 251s for {} and {} 251s for {} and {} 251s returns false 251s for {"A"=>"aye"} and {} 251s for {} and {"A"=>"aye"} 251s returns false 251s for {} and {"A"=>"aye"} 251s for {"A"=>"aye"} and {} 251s returns true 251s for {"A"=>"aye"} and {"A"=>"aye"} 251s for {"A"=>"aye"} and {"A"=>"aye"} 251s returns false 251s for {"A"=>"aye"} and {"B"=>"bee"} 251s for {"B"=>"bee"} and {"A"=>"aye"} 251s returns false 251s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 251s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 251s returns false 251s for {"A"=>"aye"} and {"A"=>"aye", "B"=>"bee"} 251s for {"A"=>"aye", "B"=>"bee"} and {"A"=>"aye"} 251s returns true 251s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 251s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 251s returns true 251s for {"C"=>"see", "A"=>"aye", "B"=>"bee"} and {"A"=>"aye", "B"=>"bee", "C"=>"see"} 251s for {"A"=>"aye", "B"=>"bee", "C"=>"see"} and {"C"=>"see", "A"=>"aye", "B"=>"bee"} 251s 251s Hamster::Hash 251s #except 251s works on a large Hash, with many combinations of input 251s with only keys that the Hash has 251s returns a Hash without those values 251s doesn't change the original Hash 251s with keys that the Hash doesn't have 251s returns a Hash without the values that it had keys for 251s doesn't change the original Hash 251s 251s Hamster::Hash 251s #fetch 251s gives precedence to default block over default argument if passed both 251s raises an ArgumentError when not passed one or 2 arguments 251s with no default provided 251s when the key exists 251s returns the value associated with the key 251s when the key does not exist 251s raises a KeyError 251s with a default value 251s when the key exists 251s returns the value associated with the key 251s when the key does not exist 251s returns the default value 251s with a default block 251s when the key exists 251s returns the value associated with the key 251s when the key does not exist 251s invokes the default block with the missing key as paramter 251s 251s Hamster::Hash 251s #fetch_values 251s when the all the requests keys exist 251s returns a vector of values for the given keys 251s when the key does not exist 251s raises a KeyError 251s 251s Hamster::Hash 251s #find 251s stops iterating when the block returns true 251s on [] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye"}] 251s with a block 251s returns ["A", "aye"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye"}] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye"}] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns ["A", "aye"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns ["B", "bee"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns [nil, "NIL"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s #detect 251s stops iterating when the block returns true 251s on [] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye"}] 251s with a block 251s returns ["A", "aye"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye"}] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye"}] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns ["A", "aye"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns ["B", "bee"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns [nil, "NIL"] 251s without a block 251s returns an Enumerator 251s on [{"A"=>"aye", "B"=>"bee", nil=>"NIL"}] 251s with a block 251s returns nil 251s without a block 251s returns an Enumerator 251s 251s Hamster::Hash 251s #flat_map 251s yields each key/val pair 251s returns the concatenation of block return values 251s doesn't change the receiver 251s returns an empty array if only empty arrays are returned by block 251s with no block 251s returns an Enumerator 251s 251s Hamster::Hash 251s #flatten 251s with flatten depth of zero 251s returns a vector of keys/value 251s without array keys or values 251s returns a vector of keys and values 251s doesn't modify the receiver 251s on an empty Hash 251s returns an empty Vector 251s with array keys 251s flattens array keys into returned vector if flatten depth is sufficient 251s doesn't modify the receiver (or its contents) 251s with array values 251s flattens array values into returned vector if flatten depth is sufficient 251s doesn't modify the receiver (or its contents) 251s with vector keys 251s flattens vector keys into returned vector if flatten depth is sufficient 251s with vector values 251s flattens vector values into returned vector if flatten depth is sufficient 251s 251s Hamster::Hash 251s #get 251s uses #hash to look up keys 251s uses #eql? to compare keys with the same hash code 251s does not use #eql? to compare keys with different hash codes 251s with a default block 251s when the key exists 251s returns the value associated with the key 251s does not call the default block even if the key is 'nil' 251s when the key does not exist 251s returns the value from the default block 251s with no default block 251s returns the value ("aye") for an existing key ("A") 251s returns the value ("bee") for an existing key ("B") 251s returns the value ("see") for an existing key ("C") 251s returns the value ("NIL") for an existing key (nil) 251s returns nil for a non-existing key 251s #[] 251s uses #hash to look up keys 251s uses #eql? to compare keys with the same hash code 251s does not use #eql? to compare keys with different hash codes 251s with a default block 251s when the key exists 251s returns the value associated with the key 251s does not call the default block even if the key is 'nil' 251s when the key does not exist 251s returns the value from the default block 251s with no default block 251s returns the value ("aye") for an existing key ("A") 251s returns the value ("bee") for an existing key ("B") 251s returns the value ("see") for an existing key ("C") 251s returns the value ("NIL") for an existing key (nil) 251s returns nil for a non-existing key 251s 251s Hamster::Hash 251s #key? 251s returns true for an existing key ("A") 251s returns true for an existing key ("B") 251s returns true for an existing key ("C") 251s returns true for an existing key (nil) 251s returns true for an existing key (2.0) 251s returns false for a non-existing key 251s uses #eql? for equality 251s returns true if the key is found and maps to nil 251s returns true if the key is found and maps to false 251s #has_key? 251s returns true for an existing key ("A") 251s returns true for an existing key ("B") 251s returns true for an existing key ("C") 251s returns true for an existing key (nil) 251s returns true for an existing key (2.0) 251s returns false for a non-existing key 251s uses #eql? for equality 251s returns true if the key is found and maps to nil 251s returns true if the key is found and maps to false 251s #include? 251s returns true for an existing key ("A") 251s returns true for an existing key ("B") 251s returns true for an existing key ("C") 251s returns true for an existing key (nil) 251s returns true for an existing key (2.0) 251s returns false for a non-existing key 251s uses #eql? for equality 251s returns true if the key is found and maps to nil 251s returns true if the key is found and maps to false 251s #member? 251s returns true for an existing key ("A") 251s returns true for an existing key ("B") 251s returns true for an existing key ("C") 251s returns true for an existing key (nil) 251s returns true for an existing key (2.0) 251s returns false for a non-existing key 251s uses #eql? for equality 251s returns true if the key is found and maps to nil 251s returns true if the key is found and maps to false 251s 251s Hamster::Hash 251s #value? 251s returns true if any key/val pair in Hash has the same value 251s returns false if no key/val pair in Hash has the same value 251s uses #== to check equality 251s works on a large hash 251s #has_value? 251s returns true if any key/val pair in Hash has the same value 251s returns false if no key/val pair in Hash has the same value 251s uses #== to check equality 251s works on a large hash 251s 251s Hamster::Hash 251s #hash 251s values are sufficiently distributed 251s differs given the same keys and different values 251s differs given the same values and different keys 251s generates the same hash value for a hash regardless of the order things were added to it 251s on an empty hash 251s returns 0 251s 251s Hamster::Hash 251s includes Immutable 251s 251s Hamster::Hash 251s #inspect 251s on [] 251s returns "Hamster::Hash[]" 251s on [{"A"=>"aye"}] 251s returns "Hamster::Hash[\"A\" => \"aye\"]" 251s on [{"A"=>"aye", "B"=>"bee", "C"=>"see"}] 251s returns "Hamster::Hash[\"A\" => \"aye\", \"B\" => \"bee\", \"C\" => \"see\"]" 251s on {} 251s returns a string which can be eval'd to get an equivalent object 251s on {"A"=>"aye"} 251s returns a string which can be eval'd to get an equivalent object 251s on {:a=>"aye", :b=>"bee", :c=>"see"} 251s returns a string which can be eval'd to get an equivalent object 251s 251s Hamster::Hash 251s #invert 251s uses the existing keys as values and values as keys 251s will select one key/value pair among multiple which have same value 251s doesn't change the original Hash 251s from a subclass of Hash 251s returns an instance of the subclass 251s 251s Hamster::Hash 251s #key 251s returns a key associated with the given value, if there is one 251s returns nil if there is no key associated with the given value 251s uses #== to compare values for equality 251s doesn't use default block if value is not found 251s 251s Hamster::Hash 251s #keys 251s returns the keys as a set 251s returns frozen String keys 251s 251s Hamster::Hash 251s #map 251s when empty 251s returns self 251s when not empty 251s with a block 251s preserves the original values 251s returns a new hash with the mapped values 251s with no block 251s returns an Enumerator 251s from a subclass 251s returns an instance of the subclass 251s #collect 251s when empty 251s returns self 251s when not empty 251s with a block 251s preserves the original values 251s returns a new hash with the mapped values 251s with no block 251s returns an Enumerator 251s from a subclass 251s returns an instance of the subclass 251s 251s Hamster::Hash 251s #marshal_dump/#marshal_load 251s can survive dumping and loading into a new process 252s is still possible to find items by key after loading 252s 252s Hamster::Hash 252s #merge 252s sets any duplicate key to the value of block if passed a block 252s yields key/value pairs in the same order as #each 252s for {} and {} 252s returns {} when passed a Hamster::Hash 252s returns {} when passed a Ruby Hash 252s doesn't change the original Hashes 252s for {"A"=>"aye"} and {} 252s returns {"A"=>"aye"} when passed a Hamster::Hash 252s returns {"A"=>"aye"} when passed a Ruby Hash 252s doesn't change the original Hashes 252s for {"A"=>"aye"} and {"A"=>"bee"} 252s returns {"A"=>"bee"} when passed a Hamster::Hash 252s returns {"A"=>"bee"} when passed a Ruby Hash 252s doesn't change the original Hashes 252s for {"A"=>"aye"} and {"B"=>"bee"} 252s returns {"A"=>"aye", "B"=>"bee"} when passed a Hamster::Hash 252s returns {"A"=>"aye", "B"=>"bee"} when passed a Ruby Hash 252s doesn't change the original Hashes 252s for [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300]] and [[150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300], [301, 301], [302, 302], [303, 303], [304, 304], [305, 305], [306, 306], [307, 307], [308, 308], [309, 309], [310, 310], [311, 311], [312, 312], [313, 313], [314, 314], [315, 315], [316, 316], [317, 317], [318, 318], [319, 319], [320, 320], [321, 321], [322, 322], [323, 323], [324, 324], [325, 325], [326, 326], [327, 327], [328, 328], [329, 329], [330, 330], [331, 331], [332, 332], [333, 333], [334, 334], [335, 335], [336, 336], [337, 337], [338, 338], [339, 339], [340, 340], [341, 341], [342, 342], [343, 343], [344, 344], [345, 345], [346, 346], [347, 347], [348, 348], [349, 349], [350, 350], [351, 351], [352, 352], [353, 353], [354, 354], [355, 355], [356, 356], [357, 357], [358, 358], [359, 359], [360, 360], [361, 361], [362, 362], [363, 363], [364, 364], [365, 365], [366, 366], [367, 367], [368, 368], [369, 369], [370, 370], [371, 371], [372, 372], [373, 373], [374, 374], [375, 375], [376, 376], [377, 377], [378, 378], [379, 379], [380, 380], [381, 381], [382, 382], [383, 383], [384, 384], [385, 385], [386, 386], [387, 387], [388, 388], [389, 389], [390, 390], [391, 391], [392, 392], [393, 393], [394, 394], [395, 395], [396, 396], [397, 397], [398, 398], [399, 399], [400, 400], [401, 401], [402, 402], [403, 403], [404, 404], [405, 405], [406, 406], [407, 407], [408, 408], [409, 409], [410, 410], [411, 411], [412, 412], [413, 413], [414, 414], [415, 415], [416, 416], [417, 417], [418, 418], [419, 419], [420, 420], [421, 421], [422, 422], [423, 423], [424, 424], [425, 425], [426, 426], [427, 427], [428, 428], [429, 429], [430, 430], [431, 431], [432, 432], [433, 433], [434, 434], [435, 435], [436, 436], [437, 437], [438, 438], [439, 439], [440, 440], [441, 441], [442, 442], [443, 443], [444, 444], [445, 445], [446, 446], [447, 447], [448, 448], [449, 449], [450, 450]] 252s returns [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300], [301, 301], [302, 302], [303, 303], [304, 304], [305, 305], [306, 306], [307, 307], [308, 308], [309, 309], [310, 310], [311, 311], [312, 312], [313, 313], [314, 314], [315, 315], [316, 316], [317, 317], [318, 318], [319, 319], [320, 320], [321, 321], [322, 322], [323, 323], [324, 324], [325, 325], [326, 326], [327, 327], [328, 328], [329, 329], [330, 330], [331, 331], [332, 332], [333, 333], [334, 334], [335, 335], [336, 336], [337, 337], [338, 338], [339, 339], [340, 340], [341, 341], [342, 342], [343, 343], [344, 344], [345, 345], [346, 346], [347, 347], [348, 348], [349, 349], [350, 350], [351, 351], [352, 352], [353, 353], [354, 354], [355, 355], [356, 356], [357, 357], [358, 358], [359, 359], [360, 360], [361, 361], [362, 362], [363, 363], [364, 364], [365, 365], [366, 366], [367, 367], [368, 368], [369, 369], [370, 370], [371, 371], [372, 372], [373, 373], [374, 374], [375, 375], [376, 376], [377, 377], [378, 378], [379, 379], [380, 380], [381, 381], [382, 382], [383, 383], [384, 384], [385, 385], [386, 386], [387, 387], [388, 388], [389, 389], [390, 390], [391, 391], [392, 392], [393, 393], [394, 394], [395, 395], [396, 396], [397, 397], [398, 398], [399, 399], [400, 400], [401, 401], [402, 402], [403, 403], [404, 404], [405, 405], [406, 406], [407, 407], [408, 408], [409, 409], [410, 410], [411, 411], [412, 412], [413, 413], [414, 414], [415, 415], [416, 416], [417, 417], [418, 418], [419, 419], [420, 420], [421, 421], [422, 422], [423, 423], [424, 424], [425, 425], [426, 426], [427, 427], [428, 428], [429, 429], [430, 430], [431, 431], [432, 432], [433, 433], [434, 434], [435, 435], [436, 436], [437, 437], [438, 438], [439, 439], [440, 440], [441, 441], [442, 442], [443, 443], [444, 444], [445, 445], [446, 446], [447, 447], [448, 448], [449, 449], [450, 450]] when passed a Hamster::Hash 252s returns [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199], [200, 200], [201, 201], [202, 202], [203, 203], [204, 204], [205, 205], [206, 206], [207, 207], [208, 208], [209, 209], [210, 210], [211, 211], [212, 212], [213, 213], [214, 214], [215, 215], [216, 216], [217, 217], [218, 218], [219, 219], [220, 220], [221, 221], [222, 222], [223, 223], [224, 224], [225, 225], [226, 226], [227, 227], [228, 228], [229, 229], [230, 230], [231, 231], [232, 232], [233, 233], [234, 234], [235, 235], [236, 236], [237, 237], [238, 238], [239, 239], [240, 240], [241, 241], [242, 242], [243, 243], [244, 244], [245, 245], [246, 246], [247, 247], [248, 248], [249, 249], [250, 250], [251, 251], [252, 252], [253, 253], [254, 254], [255, 255], [256, 256], [257, 257], [258, 258], [259, 259], [260, 260], [261, 261], [262, 262], [263, 263], [264, 264], [265, 265], [266, 266], [267, 267], [268, 268], [269, 269], [270, 270], [271, 271], [272, 272], [273, 273], [274, 274], [275, 275], [276, 276], [277, 277], [278, 278], [279, 279], [280, 280], [281, 281], [282, 282], [283, 283], [284, 284], [285, 285], [286, 286], [287, 287], [288, 288], [289, 289], [290, 290], [291, 291], [292, 292], [293, 293], [294, 294], [295, 295], [296, 296], [297, 297], [298, 298], [299, 299], [300, 300], [301, 301], [302, 302], [303, 303], [304, 304], [305, 305], [306, 306], [307, 307], [308, 308], [309, 309], [310, 310], [311, 311], [312, 312], [313, 313], [314, 314], [315, 315], [316, 316], [317, 317], [318, 318], [319, 319], [320, 320], [321, 321], [322, 322], [323, 323], [324, 324], [325, 325], [326, 326], [327, 327], [328, 328], [329, 329], [330, 330], [331, 331], [332, 332], [333, 333], [334, 334], [335, 335], [336, 336], [337, 337], [338, 338], [339, 339], [340, 340], [341, 341], [342, 342], [343, 343], [344, 344], [345, 345], [346, 346], [347, 347], [348, 348], [349, 349], [350, 350], [351, 351], [352, 352], [353, 353], [354, 354], [355, 355], [356, 356], [357, 357], [358, 358], [359, 359], [360, 360], [361, 361], [362, 362], [363, 363], [364, 364], [365, 365], [366, 366], [367, 367], [368, 368], [369, 369], [370, 370], [371, 371], [372, 372], [373, 373], [374, 374], [375, 375], [376, 376], [377, 377], [378, 378], [379, 379], [380, 380], [381, 381], [382, 382], [383, 383], [384, 384], [385, 385], [386, 386], [387, 387], [388, 388], [389, 389], [390, 390], [391, 391], [392, 392], [393, 393], [394, 394], [395, 395], [396, 396], [397, 397], [398, 398], [399, 399], [400, 400], [401, 401], [402, 402], [403, 403], [404, 404], [405, 405], [406, 406], [407, 407], [408, 408], [409, 409], [410, 410], [411, 411], [412, 412], [413, 413], [414, 414], [415, 415], [416, 416], [417, 417], [418, 418], [419, 419], [420, 420], [421, 421], [422, 422], [423, 423], [424, 424], [425, 425], [426, 426], [427, 427], [428, 428], [429, 429], [430, 430], [431, 431], [432, 432], [433, 433], [434, 434], [435, 435], [436, 436], [437, 437], [438, 438], [439, 439], [440, 440], [441, 441], [442, 442], [443, 443], [444, 444], [445, 445], [446, 446], [447, 447], [448, 448], [449, 449], [450, 450]] when passed a Ruby Hash 252s doesn't change the original Hashes 252s when merging with an empty Hash 252s returns self 252s when merging with subset Hash 252s returns self 252s when called on a subclass 252s returns an instance of the subclass 252s 252s Hamster::Hash 252s #min 252s returns the smallest key/val pair 252s #max 252s returns the largest key/val pair 252s #min_by 252s returns the smallest key/val pair (after passing it through a key function) 252s returns the first key/val pair yielded by #each in case of a tie 252s returns nil if the hash is empty 252s #max_by 252s returns the largest key/val pair (after passing it through a key function) 252s returns the first key/val pair yielded by #each in case of a tie 252s returns nil if the hash is empty 252s 252s Hamster::Hash 252s .new 252s is amenable to overriding of #initialize 252s accepts an array as initializer 252s returns a Hash which doesn't change even if initializer is mutated 252s from a subclass 252s returns a frozen instance of the subclass 252s .[] 252s accepts a Ruby Hash as initializer 252s accepts a Hamster::Hash as initializer 252s accepts an array as initializer 252s can be used with a subclass of Hamster::Hash 252s 252s Hamster::Hash 252s #none? 252s when empty 252s with a block returns true 252s with no block returns true 252s when not empty 252s with a block 252s returns false if the block ever returns true (["A", "aye"]) 252s returns true if the block always returns false 252s stops iterating as soon as the block returns true 252s returns false if the block ever returns true (["B", "bee"]) 252s returns true if the block always returns false 252s stops iterating as soon as the block returns true 252s returns false if the block ever returns true (["C", "see"]) 252s returns true if the block always returns false 252s stops iterating as soon as the block returns true 252s returns false if the block ever returns true ([nil, "NIL"]) 252s returns true if the block always returns false 252s stops iterating as soon as the block returns true 252s with no block 252s returns false 252s 252s Hamster::Hash 252s #partition 252s returns a pair of Hamster::Hashes 252s returns key/val pairs for which predicate is true in first Hash 252s returns key/val pairs for which predicate is false in second Hash 252s doesn't modify the original Hash 252s from a subclass 252s should return instances of the subclass 252s 252s Hamster::Hash 252s #pretty_print 252s prints the whole Hash on one line if it fits 252s prints each key/val pair on its own line, if not 252s prints keys and vals on separate lines, if space is very tight 252s 252s Hamster::Hash 252s #put 252s with a block 252s passes the value to the block 252s replaces the value with the result of the block 252s supports to_proc methods 252s if there is no existing association 252s passes nil to the block 252s stores the result of the block as the new value 252s with a unique key 252s preserves the original 252s returns a copy with the superset of key/value pairs 252s with a duplicate key 252s preserves the original 252s returns a copy with the superset of key/value pairs 252s with duplicate key and identical value 252s returns the original hash unmodified 252s with big hash (force nested tries) 252s returns the original hash unmodified for all changes 252s with unequal keys which hash to the same value 252s stores and can retrieve both 252s when a String is inserted as key and then mutated 252s is not affected 252s 252s Hamster::Hash 252s #reduce 252s when empty 252s returns the memo 252s when not empty 252s with a block 252s returns the final memo 252s with no block 252s uses a passed string as the name of a method to use instead 252s uses a passed symbol as the name of a method to use instead 252s #inject 252s when empty 252s returns the memo 252s when not empty 252s with a block 252s returns the final memo 252s with no block 252s uses a passed string as the name of a method to use instead 252s uses a passed symbol as the name of a method to use instead 252s 252s Hamster::Hash 252s #reject 252s when nothing matches 252s returns self 252s when only some things match 252s with a block 252s preserves the original 252s returns a set with the matching values 252s yields entries in the same order as #each 252s with no block 252s returns an Enumerator 252s on a large hash, with many combinations of input 252s still works 252s #delete_if 252s when nothing matches 252s returns self 252s when only some things match 252s with a block 252s preserves the original 252s returns a set with the matching values 252s yields entries in the same order as #each 252s with no block 252s returns an Enumerator 252s on a large hash, with many combinations of input 252s still works 252s 252s Hamster::Hash 252s #reverse_each 252s with a block 252s returns self 252s yields all key/value pairs in the opposite order as #each 252s with no block 252s returns an Enumerator 252s 252s Hamster::Hash 252s #sample 252s returns a randomly chosen item 252s 252s Hamster::Hash 252s #select 252s works on a large hash, with many combinations of input 252s when everything matches 252s returns self 252s when only some things match 252s yields entries as [key, value] pairs 252s with a block 252s preserves the original 252s returns a set with the matching values 252s with no block 252s returns an Enumerator 252s #find_all 252s works on a large hash, with many combinations of input 252s when everything matches 252s returns self 252s when only some things match 252s yields entries as [key, value] pairs 252s with a block 252s preserves the original 252s returns a set with the matching values 252s with no block 252s returns an Enumerator 252s #keep_if 253s works on a large hash, with many combinations of input 253s when everything matches 253s returns self 253s when only some things match 253s yields entries as [key, value] pairs 253s with a block 253s preserves the original 253s returns a set with the matching values 253s with no block 253s returns an Enumerator 253s 253s Hamster::Hash 253s #size 253s returns 0 for [] 253s returns 1 for [{"A"=>"aye"}] 253s returns 3 for [{"A"=>"bee", "B"=>"bee", "C"=>"see"}] 253s has the correct size after adding lots of things with colliding keys and such 253s has the correct size after lots of addings and removings 253s #length 253s returns 0 for [] 253s returns 1 for [{"A"=>"aye"}] 253s returns 3 for [{"A"=>"bee", "B"=>"bee", "C"=>"see"}] 253s has the correct size after adding lots of things with colliding keys and such 253s has the correct size after lots of addings and removings 253s 253s Hamster::Hash 253s #slice 253s with all keys present in the Hash 253s returns the sliced values 253s doesn't modify the original Hash 253s with keys aren't present in the Hash 253s returns the sliced values of the matching keys 253s doesn't modify the original Hash 253s on a Hash with a default block 253s maintains the default block 253s 253s Hamster::Hash 253s #sort 253s returns a Vector of sorted key/val pairs 253s works on large hashes 253s uses block as comparator to sort if passed a block 253s #sort_by 253s returns a Vector of key/val pairs, sorted using the block as a key function 253s 253s Hamster::Hash 253s #store 253s with a unique key 253s preserves the original 253s returns a copy with the superset of key/value pairs 253s with a duplicate key 253s preserves the original 253s returns a copy with the superset of key/value pairs 253s with duplicate key and identical value 253s returns the original hash unmodified 253s with big hash (force nested tries) 253s returns the original hash unmodified for all changes 253s with unequal keys which hash to the same value 253s stores and can retrieve both 253s when a String is inserted as key and then mutated 253s is not affected 253s 253s Hamster::Hash 253s #<= 253s for {} and {} 253s returns true 253s for {"A"=>1} and {} 253s returns false 253s for {} and {"A"=>1} 253s returns true 253s for {"A"=>1} and {"A"=>1} 253s returns true 253s for {"A"=>1} and {"A"=>2} 253s returns false 253s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 253s returns true 253s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 253s returns false 253s for {"B"=>0} and {"A"=>1, "B"=>2, "C"=>3} 253s returns false 253s #< 253s for {} and {} 253s returns false 253s for {"A"=>1} and {} 253s returns false 253s for {} and {"A"=>1} 253s returns true 253s for {"A"=>1} and {"A"=>1} 253s returns false 253s for {"A"=>1} and {"A"=>2} 253s returns false 253s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 253s returns true 253s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 253s returns false 253s for {"B"=>0} and {"A"=>1, "B"=>2, "C"=>3} 253s returns false 253s 253s Hamster::Hash 253s #>= 253s for {} and {} 253s returns true 253s for {"A"=>1} and {} 253s returns true 254s for {} and {"A"=>1} 254s returns false 254s for {"A"=>1} and {"A"=>1} 254s returns true 254s for {"A"=>1} and {"A"=>2} 254s returns false 254s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 254s returns true 254s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 254s returns false 254s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>0} 254s returns false 254s #> 254s for {} and {} 254s returns false 254s for {"A"=>1} and {} 254s returns true 254s for {} and {"A"=>1} 254s returns false 254s for {"A"=>1} and {"A"=>1} 254s returns false 254s for {"A"=>1} and {"A"=>2} 254s returns false 254s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>2} 254s returns true 254s for {"B"=>2} and {"A"=>1, "B"=>2, "C"=>3} 254s returns false 254s for {"A"=>1, "B"=>2, "C"=>3} and {"B"=>0} 254s returns false 254s 254s Hamster::Hash 254s #take 254s returns the first N key/val pairs from hash 254s #take_while 254s passes elements to the block until the block returns nil/false 254s returns an array of all elements before the one which returned nil/false 254s passes all elements if the block never returns nil/false 254s 254s Hamster::Hash 254s #to_a 254s returns an Array of [key, value] pairs in same order as #each 254s 254s Hamster::Hash 254s #to_hash 254s converts an empty Hamster::Hash to an empty Ruby Hash 254s converts a non-empty Hamster::Hash to a Hash with the same keys and values 254s doesn't modify the receiver 254s #to_h 254s converts an empty Hamster::Hash to an empty Ruby Hash 254s converts a non-empty Hamster::Hash to a Hash with the same keys and values 254s doesn't modify the receiver 254s 254s Hamster::Hash 254s #to_proc 254s on Hash without default proc 254s returns a Proc instance 254s returns a Proc that returns the value of an existing key 254s returns a Proc that returns nil for a missing key 254s on Hash with a default proc 254s returns a Proc instance 254s returns a Proc that returns the value of an existing key 254s returns a Proc that returns the result of the hash's default proc for a missing key 254s 254s Hamster::Hash 254s #values_at 254s on Hash without default proc 254s returns an empty vector when no keys are given 254s returns a vector of values for the given keys 254s fills nil when keys are missing 254s on Hash with default proc 254s fills the result of the default proc when keys are missing 254s 254s Hamster::Hash 254s #values 254s returns the keys as a Vector 254s with duplicates 254s returns the keys as a Vector 254s 254s Hamster::Immutable 254s #dup 254s returns self 254s #clone 254s returns self 254s 254s Hamster::Immutable 254s #immutable? 254s object constructed after its class becomes Immutable 254s returns true 254s object constructed before its class becomes Immutable 254s that are not frozen 254s returns false 254s that are frozen 254s returns true 254s 254s Hamster::Immutable 254s #memoize 254s keeps the receiver frozen and immutable 254s when called multiple times 254s doesn't evaluate the memoized method more than once 254s when making a copy 254s clears all memory 254s 254s Hamster::Immutable 254s freezes the instance 254s subclass hides all public methods 254s freezes the instance 254s 254s Hamster::Immutable 254s #transform 254s preserves the original 254s returns a new instance with the updated values 254s 254s Hamster::Immutable 254s #transform_unless 254s when the condition is false 254s preserves the original 254s returns a new instance with the updated values 254s when the condition is true 254s preserves the original 254s returns the original 254s 254s Hamster::List 254s #add 254s on [] with "A" 254s preserves the original 254s returns ["A"] 254s on ["A"] with "B" 254s preserves the original 254s returns ["B", "A"] 254s on ["A"] with "A" 254s preserves the original 254s returns ["A", "A"] 254s on ["A", "B", "C"] with "D" 254s preserves the original 254s returns ["D", "A", "B", "C"] 254s 254s Hamster::List 254s #all? 254s on a really big list 254s doesn't run out of stack 254s when empty 254s with a block returns true 254s with no block returns true 254s when not empty 254s with a block 254s if the block always returns true 254s returns true 254s if the block ever returns false 254s returns false 254s with no block 254s if all values are truthy 254s returns true 254s if any value is nil 254s returns false 254s if any value is false 254s returns false 254s 254s Hamster::List 254s #any? 254s on a really big list 254s doesn't run out of stack 254s when empty 254s with a block returns false 254s with no block returns false 254s when not empty 254s with a block 254s returns true if the block ever returns true ("A") 254s returns true if the block ever returns true ("B") 254s returns true if the block ever returns true ("C") 254s returns true if the block ever returns true (nil) 254s returns false if the block always returns false 254s with no block 254s returns true if any value is truthy 254s returns false if all values are falsey 254s 254s Hamster::List 254s #append 254s is lazy 254s on [] and [] 254s preserves the left 254s preserves the right 254s returns [] 254s on ["A"] and [] 254s preserves the left 254s preserves the right 254s returns ["A"] 254s on [] and ["A"] 254s preserves the left 254s preserves the right 254s returns ["A"] 254s on ["A", "B"] and ["C", "D"] 254s preserves the left 254s preserves the right 254s returns ["A", "B", "C", "D"] 254s #concat 254s is lazy 254s on [] and [] 254s preserves the left 254s preserves the right 254s returns [] 254s on ["A"] and [] 254s preserves the left 254s preserves the right 254s returns ["A"] 254s on [] and ["A"] 254s preserves the left 254s preserves the right 254s returns ["A"] 254s on ["A", "B"] and ["C", "D"] 254s preserves the left 254s preserves the right 254s returns ["A", "B", "C", "D"] 254s #+ 254s is lazy 254s on [] and [] 254s preserves the left 254s preserves the right 254s returns [] 254s on ["A"] and [] 254s preserves the left 254s preserves the right 254s returns ["A"] 254s on [] and ["A"] 254s preserves the left 254s preserves the right 254s returns ["A"] 254s on ["A", "B"] and ["C", "D"] 254s preserves the left 254s preserves the right 254s returns ["A", "B", "C", "D"] 254s 254s Hamster::List 254s #at 254s on a really big list 254s doesn't run out of stack 254s [] with 10 254s returns nil 254s ["A"] with 10 254s returns nil 254s ["A", "B", "C"] with 0 254s returns "A" 254s ["A", "B", "C"] with 2 254s returns "C" 254s ["A", "B", "C"] with -1 254s returns "C" 254s ["A", "B", "C"] with -2 254s returns "B" 254s ["A", "B", "C"] with -4 254s returns nil 254s 254s Hamster::List 254s #break 254s is lazy 254s on [] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [1] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [1, 2] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [1, 2, 3] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [1, 2, 3, 4] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [2, 3, 4] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [3, 4] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s on [4] 254s with a block 254s preserves the original 254s returns a frozen array with two items 254s correctly identifies the prefix 254s correctly identifies the remainder 254s without a block 254s returns a frozen array with two items 254s returns self as the prefix 254s leaves the remainder empty 254s 254s Hamster::List 254s #car 254s is responded to 254s on [] 254s preserves the original 254s returns nil 254s #car 254s is responded to 254s on ["A"] 254s preserves the original 254s returns "A" 254s #car 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns "A" 254s #cadr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns "B" 254s #caddr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns "C" 254s #cadddr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns nil 254s #caddddr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns nil 254s #cdr 254s is responded to 254s on [] 254s preserves the original 254s returns Hamster::List[] 254s #cdr 254s is responded to 254s on ["A"] 254s preserves the original 254s returns Hamster::List[] 254s #cdr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns Hamster::List["B", "C"] 254s #cddr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns Hamster::List["C"] 254s #cdddr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns Hamster::List[] 254s #cddddr 254s is responded to 254s on ["A", "B", "C"] 254s preserves the original 254s returns Hamster::List[] 254s 254s Hamster::List 254s #chunk 254s is lazy 254s on [] 254s preserves the original 254s returns [] 254s on ["A"] 254s preserves the original 254s returns [Hamster::List["A"]] 254s on ["A", "B", "C"] 254s preserves the original 254s returns [Hamster::List["A", "B"], Hamster::List["C"]] 254s 254s Hamster::List 254s #clear 254s on [] 254s preserves the original 254s returns an empty list 254s on ["A"] 254s preserves the original 254s returns an empty list 254s on ["A", "B", "C"] 254s preserves the original 254s returns an empty list 254s 254s Hamster::List 254s #combination 254s is lazy 254s on ["A", "B", "C", "D"] in groups of 1 254s preserves the original 254s returns [Hamster::List["A"], Hamster::List["B"], Hamster::List["C"], Hamster::List["D"]] 254s on ["A", "B", "C", "D"] in groups of 2 254s preserves the original 254s returns [Hamster::List["A", "B"], Hamster::List["A", "C"], Hamster::List["A", "D"], Hamster::List["B", "C"], Hamster::List["B", "D"], Hamster::List["C", "D"]] 254s on ["A", "B", "C", "D"] in groups of 3 254s preserves the original 254s returns [Hamster::List["A", "B", "C"], Hamster::List["A", "B", "D"], Hamster::List["A", "C", "D"], Hamster::List["B", "C", "D"]] 254s on ["A", "B", "C", "D"] in groups of 4 254s preserves the original 254s returns [Hamster::List["A", "B", "C", "D"]] 254s on ["A", "B", "C", "D"] in groups of 0 254s preserves the original 254s returns [Hamster::List[]] 254s on ["A", "B", "C", "D"] in groups of 5 254s preserves the original 254s returns [] 254s on [] in groups of 0 254s preserves the original 254s returns [Hamster::List[]] 254s on [] in groups of 1 254s preserves the original 254s returns [] 254s 254s Hamster::List 254s #compact 254s is lazy 254s on [] 254s preserves the original 254s returns [] 254s on ["A"] 254s preserves the original 254s returns ["A"] 254s on ["A", "B", "C"] 254s preserves the original 254s returns ["A", "B", "C"] 254s on [nil] 254s preserves the original 254s returns [] 254s on [nil, "B"] 254s preserves the original 254s returns ["B"] 254s on ["A", nil] 254s preserves the original 254s returns ["A"] 254s on [nil, nil] 254s preserves the original 254s returns [] 254s on ["A", nil, "C"] 254s preserves the original 254s returns ["A", "C"] 254s on [nil, "B", nil] 254s preserves the original 254s returns ["B"] 254s 254s Hamster::List 254s #<=> 254s with [] and [1] 254s returns -1 254s with [1] and [] 254s returns 1 254s with [] and [] 254s returns 0 254s with [1] and [2] 254s returns -1 254s with [2] and [1] 254s returns 1 254s with [1] and [1] 254s returns 0 254s with [1] and [1, 2] 254s returns -1 254s with [1, 2] and [1] 254s returns 1 254s with [1] and [1] 254s returns 0 254s with [2, 3, 4] and [3, 4, 5] 254s returns -1 254s with [3, 4, 5] and [2, 3, 4] 254s returns 1 254s with [2, 3, 4] and [2, 3, 4] 254s returns 0 254s 254s Hamster::List 254s #cons 254s on [] with "A" 254s preserves the original 254s returns ["A"] 254s on ["A"] with "B" 254s preserves the original 254s returns ["B", "A"] 254s on ["A"] with "A" 254s preserves the original 254s returns ["A", "A"] 254s on ["A", "B", "C"] with "D" 254s preserves the original 254s returns ["D", "A", "B", "C"] 254s 254s Hamster 254s .list 254s with no arguments 254s always returns the same instance 254s returns an empty list 254s with a number of items 254s always returns a different instance 254s is the same as repeatedly using #cons 254s .stream 254s with no block 254s returns an empty list 254s with a block 254s repeatedly calls the block 254s .interval 254s for numbers 254s is equivalent to a list with explicit values 254s for strings 254s is equivalent to a list with explicit values 254s .repeat 254s returns an infinite list with specified value for each element 254s .replicate 254s returns a list with the specified value repeated the specified number of times 254s .iterate 254s returns an infinite list where the first item is calculated by applying the block on the initial argument, the second item by applying the function on the previous result and so on 254s .enumerate 254s returns a list based on the values yielded from the enumerator 254s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.1k2Ta7/build.Gja/src/spec/lib/hamster/list/construction_spec.rb:94:in `block (3 levels) in '. 254s realizes values as they are needed 254s [] 254s takes a variable number of items and returns a list 254s returns an empty list when called without arguments 254s 254s Hamster::List 254s on [] 254s returns self 254s on ["A"] 254s returns self 254s on ["A", "B", "C"] 254s returns self 254s on [] 254s returns self 254s on ["A"] 254s returns self 254s on ["A", "B", "C"] 254s returns self 254s 254s Hamster::List 254s #count 254s on a really big list 254s doesn't run out of stack 254s on [] 254s with a block 254s returns 0 254s without a block 254s returns length 254s on [1] 254s with a block 254s returns 1 254s without a block 254s returns length 254s on [1, 2] 254s with a block 254s returns 1 254s without a block 254s returns length 254s on [1, 2, 3] 254s with a block 254s returns 2 254s without a block 254s returns length 254s on [1, 2, 3, 4] 254s with a block 254s returns 2 254s without a block 254s returns length 254s on [1, 2, 3, 4, 5] 254s with a block 254s returns 3 254s without a block 254s returns length 254s 254s Hamster 254s #cycle 254s is lazy 254s with an empty list 254s returns an empty list 254s with a non-empty list 254s preserves the original 254s infinitely cycles through all values 254s 254s Hamster::List 254s #delete_at 254s removes the element at the specified index 254s makes no modification if the index is out of range 254s 254s Hamster::List 254s #delete 254s removes elements that are #== to the argument 254s 254s Hamster::List 254s #drop 254s is lazy 254s with 10 from [] 254s preserves the original 254s returns [] 254s with 10 from ["A"] 254s preserves the original 254s returns [] 254s with -1 from ["A"] 254s preserves the original 254s returns ["A"] 254s with 0 from ["A", "B", "C"] 254s preserves the original 254s returns ["A", "B", "C"] 254s with 2 from ["A", "B", "C"] 254s preserves the original 254s returns ["C"] 254s 254s Hamster::List 254s #drop_while 254s is lazy 254s on [] 254s with a block 254s preserves the original 254s returns [] 254s without a block 254s returns an Enumerator 254s on ["A"] 254s with a block 254s preserves the original 254s returns [] 254s without a block 254s returns an Enumerator 254s on ["A", "B", "C"] 254s with a block 254s preserves the original 254s returns ["C"] 254s without a block 254s returns an Enumerator 254s 254s Hamster::List 254s #each_chunk 254s on a really big list 254s doesn't run out of stack 254s on [] 254s with a block 254s preserves the original 254s iterates over the items in order 254s returns self 254s without a block 254s preserves the original 254s returns an Enumerator 254s on ["A"] 254s with a block 254s preserves the original 254s iterates over the items in order 254s returns self 254s without a block 254s preserves the original 254s returns an Enumerator 254s on ["A", "B", "C"] 254s with a block 254s preserves the original 254s iterates over the items in order 254s returns self 254s without a block 254s preserves the original 254s returns an Enumerator 254s #each_slice 254s on a really big list 255s doesn't run out of stack 255s on [] 255s with a block 255s preserves the original 255s iterates over the items in order 255s returns self 255s without a block 255s preserves the original 255s returns an Enumerator 255s on ["A"] 255s with a block 255s preserves the original 255s iterates over the items in order 255s returns self 255s without a block 255s preserves the original 255s returns an Enumerator 255s on ["A", "B", "C"] 255s with a block 255s preserves the original 255s iterates over the items in order 255s returns self 255s without a block 255s preserves the original 255s returns an Enumerator 255s 255s Hamster::List 255s #each 255s on a really big list 255s doesn't run out of stack 255s on [] 255s with a block 255s iterates over the items in order 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s iterates over the items in order 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A", "B", "C"] 255s with a block 255s iterates over the items in order 255s returns nil 255s without a block 255s returns an Enumerator 255s 255s Hamster::List 255s #each_with_index 255s with no block 255s returns an Enumerator 255s with a block 255s returns self 255s iterates over the items in order, yielding item and index 255s 255s Hamster::List 255s #empty? 255s on a really big list 255s doesn't run out of stack 255s on [] 255s returns true 255s on ["A"] 255s returns false 255s on ["A", "B", "C"] 255s returns false 255s 255s Hamster::List 255s Hamster::List["A", "B", "C"] should == ["A", "B", "C"] 255s Hamster::List["A", "B", "C"] should not eql? ["A", "B", "C"] 255s Hamster::List["A", "B", "C"] should not == # 255s Hamster::List["A", "B", "C"] should not eql? # 255s Hamster::List[] should == [] 255s Hamster::List[] should not eql? [] 255s Hamster::List[] should eql? Hamster::List[] 255s Hamster::List[] should == Hamster::List[] 255s Hamster::List[] should not eql? Hamster::List[nil] 255s Hamster::List["A"] should not eql? Hamster::List[] 255s Hamster::List["A"] should eql? Hamster::List["A"] 255s Hamster::List["A"] should == Hamster::List["A"] 255s Hamster::List["A"] should not eql? Hamster::List["B"] 255s Hamster::List["A", "B"] should not eql? Hamster::List["A"] 255s Hamster::List["A", "B", "C"] should eql? Hamster::List["A", "B", "C"] 255s Hamster::List["A", "B", "C"] should == Hamster::List["A", "B", "C"] 255s Hamster::List["C", "A", "B"] should not eql? Hamster::List["A", "B", "C"] 255s Hamster::List["A"] should == ["A"] 255s ["A"] should == Hamster::List["A"] 255s Hamster::List["A"] should not eql? ["A"] 255s ["A"] should not eql? Hamster::List["A"] 255s #eql? 255s on a really big list 255s doesn't run out of stack 255s 255s Hamster::List 255s #fill 255s can replace a range of items at the beginning of a list 255s can replace a range of items in the middle of a list 255s can replace a range of items at the end of a list 255s can replace all the items in a list 255s can fill past the end of the list 255s is lazy 255s with 1 argument 255s replaces all the items in the list by default 255s with 2 arguments 255s replaces up to the end of the list by default 255s when index and length are 0 255s leaves the list unmodified 255s 255s Hamster::List 255s #find_all 255s is lazy 255s with an empty array 255s with a block 255s preserves the original 255s returns the found list 255s without a block 255s returns an Enumerator 255s with a single item array 255s with a block 255s preserves the original 255s returns the found list 255s without a block 255s returns an Enumerator 255s with a multi-item array 255s with a block 255s preserves the original 255s returns the found list 255s without a block 255s returns an Enumerator 255s with a multi-item single find_allable array 255s with a block 255s preserves the original 255s returns the found list 255s without a block 255s returns an Enumerator 255s with a multi-item multi-find_allable array 255s with a block 255s preserves the original 255s returns the found list 255s without a block 255s returns an Enumerator 255s 255s Hamster::List 255s #find_index 255s on a really big list 255s doesn't run out of stack 255s looking for "A" in [] 255s returns nil 255s looking for nil in [] 255s returns nil 255s looking for "A" in ["A"] 255s returns 0 255s looking for "B" in ["A"] 255s returns nil 255s looking for nil in ["A"] 255s returns nil 255s looking for "A" in ["A", "B", nil] 255s returns 0 255s looking for "B" in ["A", "B", nil] 255s returns 1 255s looking for nil in ["A", "B", nil] 255s returns 2 255s looking for "C" in ["A", "B", nil] 255s returns nil 255s looking for 2 in [2] 255s returns 0 255s looking for 2.0 in [2] 255s returns 0 255s looking for 2.0 in [2.0] 255s returns 0 255s looking for 2 in [2.0] 255s returns 0 255s #index 255s on a really big list 255s doesn't run out of stack 255s looking for "A" in [] 255s returns nil 255s looking for nil in [] 255s returns nil 255s looking for "A" in ["A"] 255s returns 0 255s looking for "B" in ["A"] 255s returns nil 255s looking for nil in ["A"] 255s returns nil 255s looking for "A" in ["A", "B", nil] 255s returns 0 255s looking for "B" in ["A", "B", nil] 255s returns 1 255s looking for nil in ["A", "B", nil] 255s returns 2 255s looking for "C" in ["A", "B", nil] 255s returns nil 255s looking for 2 in [2] 255s returns 0 255s looking for 2.0 in [2] 255s returns 0 255s looking for 2.0 in [2.0] 255s returns 0 255s looking for 2 in [2.0] 255s returns 0 255s 255s Hamster::List 255s #find 255s on a really big list 255s doesn't run out of stack 255s on [] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on [] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s returns "A" 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns "A" 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns "B" 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s #detect 255s on a really big list 255s doesn't run out of stack 255s on [] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on [] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s returns "A" 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A"] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns "A" 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns "B" 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 255s returns nil 255s without a block 255s returns an Enumerator 255s on ["A", "B", nil] 255s with a block 256s returns nil 256s without a block 256s returns an Enumerator 256s 256s Hamster::List 256s #flat_map 256s with an empty list 256s returns the flattened values as a Hamster::List 256s returns a Hamster::List 256s with a block that returns an empty list 256s returns the flattened values as a Hamster::List 256s returns a Hamster::List 256s with a list of one item 256s returns the flattened values as a Hamster::List 256s returns a Hamster::List 256s with a list of multiple items 256s returns the flattened values as a Hamster::List 256s returns a Hamster::List 256s 256s Hamster 256s #flatten 256s is lazy 256s on [] 256s preserves the original 256s returns an empty list 256s on ["A"] 256s preserves the original 256s returns an empty list 256s on ["A", "B", "C"] 256s preserves the original 256s returns an empty list 256s on ["A", Hamster::List["B"], "C"] 256s preserves the original 256s returns an empty list 256s on [Hamster::List["A"], Hamster::List["B"], Hamster::List["C"]] 256s preserves the original 256s returns an empty list 256s 256s Hamster::List 256s #grep 256s is lazy 256s without a block 256s on [] 256s returns [] 256s on ["A"] 256s returns ["A"] 256s on [1] 256s returns [] 256s on ["A", 2, "C"] 256s returns ["A", "C"] 256s with a block 256s on [] 256s preserves the original 256s returns [] 256s on ["A"] 256s preserves the original 256s returns ["a"] 256s on [1] 256s preserves the original 256s returns [] 256s on ["A", 2, "C"] 256s preserves the original 256s returns ["a", "c"] 256s 256s Hamster::List 256s #group_by 256s on a really big list 256s doesn't run out of stack 256s with a block 256s on [] 256s returns [] 256s on [1] 256s returns [{true=>Hamster::List[1]}] 256s on [1, 2, 3, 4] 256s returns [{true=>Hamster::List[3, 1], false=>Hamster::List[4, 2]}] 256s without a block 256s on [] 256s returns [] 256s on [1] 256s returns [{1=>Hamster::List[1]}] 256s on [1, 2, 3, 4] 256s returns [{1=>Hamster::List[1], 2=>Hamster::List[2], 3=>Hamster::List[3], 4=>Hamster::List[4]}] 256s #group 256s on a really big list 256s doesn't run out of stack 256s with a block 256s on [] 256s returns [] 256s on [1] 256s returns [{true=>Hamster::List[1]}] 256s on [1, 2, 3, 4] 256s returns [{true=>Hamster::List[3, 1], false=>Hamster::List[4, 2]}] 256s without a block 256s on [] 256s returns [] 256s on [1] 256s returns [{1=>Hamster::List[1]}] 256s on [1, 2, 3, 4] 256s returns [{1=>Hamster::List[1], 2=>Hamster::List[2], 3=>Hamster::List[3], 4=>Hamster::List[4]}] 256s 256s Hamster::List 256s #hash 256s values are sufficiently distributed 256s on a really big list 257s doesn't run out of stack 257s on an empty list 257s returns 0 257s 257s Hamster::List 257s #head 257s on [] 257s returns nil 257s on ["A"] 257s returns "A" 257s on ["A", "B", "C"] 257s returns "A" 257s #first 257s on [] 257s returns nil 257s on ["A"] 257s returns "A" 257s on ["A", "B", "C"] 257s returns "A" 257s 257s Hamster::List 257s #include? 257s on a really big list 257s doesn't run out of stack 257s on [] 257s returns false 257s on [] 257s returns false 257s on ["A"] 257s returns true 257s on ["A"] 257s returns false 257s on ["A"] 257s returns false 257s on ["A", "B", nil] 257s returns true 257s on ["A", "B", nil] 257s returns true 257s on ["A", "B", nil] 257s returns true 257s on ["A", "B", nil] 257s returns false 257s on [2] 257s returns true 257s on [2] 257s returns true 257s on [2.0] 257s returns true 257s on [2.0] 257s returns true 257s #member? 257s on a really big list 257s doesn't run out of stack 257s on [] 257s returns false 257s on [] 257s returns false 257s on ["A"] 257s returns true 257s on ["A"] 257s returns false 257s on ["A"] 257s returns false 257s on ["A", "B", nil] 257s returns true 257s on ["A", "B", nil] 257s returns true 257s on ["A", "B", nil] 257s returns true 257s on ["A", "B", nil] 257s returns false 257s on [2] 257s returns true 257s on [2] 257s returns true 257s on [2.0] 257s returns true 257s on [2.0] 257s returns true 257s 257s Hamster::List 257s #index 257s on a really big list 257s doesn't run out of stack 257s looking for "A" in [] 257s returns nil 257s looking for nil in [] 257s returns nil 257s looking for "A" in ["A"] 257s returns 0 257s looking for "B" in ["A"] 257s returns nil 257s looking for nil in ["A"] 257s returns nil 257s looking for "A" in ["A", "B", nil] 257s returns 0 257s looking for "B" in ["A", "B", nil] 257s returns 1 257s looking for nil in ["A", "B", nil] 257s returns 2 257s looking for "C" in ["A", "B", nil] 257s returns nil 257s looking for 2 in [2] 257s returns 0 257s looking for 2.0 in [2] 257s returns 0 257s looking for 2.0 in [2.0] 257s returns 0 257s looking for 2 in [2.0] 257s returns 0 257s 257s Hamster::List 257s #indices 257s when called with a block 257s is lazy 257s on a large list which doesn't contain desired item 257s doesn't blow the stack 257s looking for "A" in [] 257s returns [] 257s looking for "B" in ["A"] 257s returns [] 257s looking for "B" in ["A", "B", "A"] 257s returns [1] 257s looking for "A" in ["A", "B", "A"] 257s returns [0, 2] 257s looking for 2 in [2] 257s returns [0] 257s looking for 2.0 in [2] 257s returns [0] 257s looking for 2.0 in [2.0] 257s returns [0] 257s looking for 2 in [2.0] 257s returns [0] 257s when called with a single argument 257s is lazy 257s looking for "A" in [] 257s returns [] 257s looking for "B" in ["A"] 257s returns [] 257s looking for "B" in ["A", "B", "A"] 257s returns [1] 257s looking for "A" in ["A", "B", "A"] 257s returns [0, 2] 257s looking for 2 in [2] 257s returns [0] 257s looking for 2.0 in [2] 257s returns [0] 257s looking for 2.0 in [2.0] 257s returns [0] 257s looking for 2 in [2.0] 257s returns [0] 257s 257s Hamster::List 257s #init 257s is lazy 257s on [] 257s preserves the original 257s returns the list without the last element: [] 257s on ["A"] 257s preserves the original 257s returns the list without the last element: [] 257s on ["A", "B", "C"] 257s preserves the original 257s returns the list without the last element: ["A", "B"] 257s 257s Hamster::List 257s #inits 257s is lazy 257s on [] 257s preserves the original 257s returns [] 257s on ["A"] 257s preserves the original 257s returns [Hamster::List["A"]] 257s on ["A", "B", "C"] 257s preserves the original 257s returns [Hamster::List["A"], Hamster::List["A", "B"], Hamster::List["A", "B", "C"]] 257s 257s Hamster::List 257s #insert 257s can add items at the beginning of a list 257s can add items in the middle of a list 257s can add items at the end of a list 257s can add items past the end of a list 257s accepts a negative index, which counts back from the end of the list 257s raises IndexError if a negative index is too great 257s is lazy 257s 257s Hamster::List 257s #inspect 257s on a really big list 257s doesn't run out of stack 257s on [] 257s returns "Hamster::List[]" 257s returns a string which can be eval'd to get an equivalent object 257s on ["A"] 257s returns "Hamster::List[\"A\"]" 257s returns a string which can be eval'd to get an equivalent object 257s on ["A", "B", "C"] 257s returns "Hamster::List[\"A\", \"B\", \"C\"]" 257s returns a string which can be eval'd to get an equivalent object 257s 257s Hamster::List 257s #intersperse 257s is lazy 257s on [] 257s preserves the original 257s returns [] 257s on ["A"] 257s preserves the original 257s returns ["A"] 257s on ["A", "B", "C"] 257s preserves the original 257s returns ["A", "|", "B", "|", "C"] 257s 257s Hamster::List 257s #join 257s on a really big list 257s doesn't run out of stack 257s with a separator 257s on [] 257s preserves the original 257s returns "" 257s on ["A"] 257s preserves the original 257s returns "A" 257s on ["A", "B", "C"] 257s preserves the original 257s returns "A|B|C" 257s without a separator 257s on [] 257s preserves the original 257s returns "" 257s on ["A"] 257s preserves the original 257s returns "A" 257s on ["A", "B", "C"] 257s preserves the original 257s returns "ABC" 257s without a separator (with global default separator set) 257s uses the default global separator 257s 257s Hamster::List 257s #last 257s on a really big list 257s doesn't run out of stack 257s on [] 257s returns nil 257s on ["A"] 257s returns "A" 257s on ["A", "B", "C"] 257s returns "C" 257s 257s Hamster::List 257s #<< 257s adds an item onto the end of a list 257s on an empty list 257s returns a list with one item 257s 257s Hamster::List 257s #map 257s is lazy 257s on [] 257s with a block 257s preserves the original 257s returns [] 257s is lazy 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s preserves the original 257s returns ["a"] 257s is lazy 257s without a block 257s returns an Enumerator 257s on ["A", "B", "C"] 257s with a block 257s preserves the original 257s returns ["a", "b", "c"] 257s is lazy 257s without a block 257s returns an Enumerator 257s #collect 257s is lazy 257s on [] 257s with a block 257s preserves the original 257s returns [] 257s is lazy 257s without a block 257s returns an Enumerator 257s on ["A"] 257s with a block 257s preserves the original 257s returns ["a"] 257s is lazy 257s without a block 257s returns an Enumerator 257s on ["A", "B", "C"] 257s with a block 257s preserves the original 257s returns ["a", "b", "c"] 257s is lazy 257s without a block 257s returns an Enumerator 257s 257s Hamster::List 257s #max 257s on a really big list 257s doesn't run out of stack 257s with a block 257s on [] 257s returns nil 257s on ["A"] 257s returns "A" 257s on ["Ichi", "Ni", "San"] 257s returns "Ichi" 257s without a block 257s on [] 257s returns nil 257s on ["A"] 257s returns "A" 257s on ["Ichi", "Ni", "San"] 257s returns "San" 257s 257s Hamster::List 257s without a comparator 257s on an empty list 257s returns an empty list 257s on a single list 257s returns the list 257s with multiple lists 257s merges the lists based on natural sort order 257s with a comparator 257s on an empty list 257s returns an empty list 257s on a single list 257s returns the list 257s with multiple lists 257s merges the lists based on the specified transformer 257s 257s Hamster::List 257s without a comparator 257s on an empty list 257s returns an empty list 257s on a single list 257s returns the list 257s with multiple lists 257s merges the lists based on natural sort order 257s with a comparator 257s on an empty list 257s returns an empty list 257s on a single list 257s returns the list 257s with multiple lists 257s merges the lists based on the specified comparator 257s 257s Hamster::List 257s #min 257s on a really big list 258s doesn't run out of stack 258s with a block 258s on [] 258s returns nil 258s on ["A"] 258s returns "A" 258s on ["Ichi", "Ni", "San"] 258s returns "Ni" 258s without a block 258s on [] 258s returns nil 258s on ["A"] 258s returns "A" 258s on ["Ichi", "Ni", "San"] 258s returns "Ichi" 258s 258s Hamster::List 258s ensures each node of a lazy list will only be realized on ONE thread, even when accessed by multiple threads 258s doesn't go into an infinite loop if lazy list block raises an exception 258s doesn't give horrendously bad performance if thread realizing the list sleeps (PENDING: Temporarily skipped with xit) 258s 258s Hamster::List 258s #none? 258s on a really big list 258s doesn't run out of stack 258s when empty 258s with a block returns true 258s with no block returns true 258s when not empty 258s with a block 258s returns false if the block ever returns true ("A") 258s returns false if the block ever returns true ("B") 258s returns false if the block ever returns true ("C") 258s returns false if the block ever returns true (nil) 258s returns true if the block always returns false 258s with no block 258s returns false if any value is truthy 258s returns true if all values are falsey 258s 258s Hamster::List 258s #one? 258s on a really big list 258s doesn't run out of stack 258s when empty 258s with a block returns false 258s with no block returns false 258s when not empty 258s with a block 258s returns false if the block returns true more than once 258s returns false if the block never returns true 258s returns true if the block only returns true once 258s with no block 258s returns false if more than one value is truthy 258s returns true if only one value is truthy 258s 258s Hamster::List 258s #partition 258s is lazy 258s calls the passed block only once for each item 258s returns a lazy list of items for which predicate is true 258s returns a lazy list of items for which predicate is false 258s calls the passed block only once for each item, even with multiple threads 258s on [] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1, 2] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1, 2, 3] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [1, 2, 3, 4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [2, 3, 4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [3, 4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s on [4] 258s with a block 258s preserves the original 258s returns a frozen array with two items 258s correctly identifies the matches 258s correctly identifies the remainder 258s without a block 258s returns an Enumerator 258s 258s Hamster::List 258s #permutation 258s with no block 258s returns an Enumerator 258s with no argument 258s yields all permutations of the list 258s with a length argument 258s yields all N-size permutations of the list 258s with a length argument greater than length of list 258s yields nothing 258s with a length argument of 0 258s yields an empty list 258s with a block 258s returns the original list 258s 258s Hamster::List 258s #pop 258s with an empty list 258s returns an empty list 258s with a list with a few items 258s removes the last item 258s 258s Hamster::List 258s #product 258s on a really big list 258s doesn't run out of stack 258s on [] 258s returns 1 258s on [2] 258s returns 2 258s on [1, 3, 5, 7, 11] 258s returns 1155 258s 258s Hamster::List 258s #reduce 258s on a really big list 259s doesn't run out of stack 259s on [] 259s with an initial value of 10 and a block 259s returns 10 259s on [1] 259s with an initial value of 10 and a block 259s returns 9 259s on [1, 2, 3] 259s with an initial value of 10 and a block 259s returns 4 259s on [] 259s with no initial value and a block 259s returns nil 259s on [1] 259s with no initial value and a block 259s returns 1 259s on [1, 2, 3] 259s with no initial value and a block 259s returns -4 259s with no block and a symbol argument 259s uses the symbol as the name of a method to reduce with 259s with no block and a string argument 259s uses the string as the name of a method to reduce with 259s #inject 259s on a really big list 259s doesn't run out of stack 259s on [] 259s with an initial value of 10 and a block 259s returns 10 259s on [1] 259s with an initial value of 10 and a block 259s returns 9 259s on [1, 2, 3] 259s with an initial value of 10 and a block 259s returns 4 259s on [] 259s with no initial value and a block 259s returns nil 259s on [1] 259s with no initial value and a block 259s returns 1 259s on [1, 2, 3] 259s with no initial value and a block 259s returns -4 259s with no block and a symbol argument 259s uses the symbol as the name of a method to reduce with 259s with no block and a string argument 259s uses the string as the name of a method to reduce with 259s 259s Hamster::List 259s #reject 259s is lazy 259s on [] 259s with a block 259s returns [] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A"] 259s with a block 259s returns ["A"] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A", "B", "C"] 259s with a block 259s returns ["A", "B", "C"] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A", "b", "C"] 259s with a block 259s returns ["A", "C"] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["a", "b", "c"] 259s with a block 259s returns [] 259s is lazy 259s without a block 259s returns an Enumerator 259s #delete_if 259s is lazy 259s on [] 259s with a block 259s returns [] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A"] 259s with a block 259s returns ["A"] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A", "B", "C"] 259s with a block 259s returns ["A", "B", "C"] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A", "b", "C"] 259s with a block 259s returns ["A", "C"] 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["a", "b", "c"] 259s with a block 259s returns [] 259s is lazy 259s without a block 259s returns an Enumerator 259s 259s Hamster::List 259s #reverse 259s is lazy 259s on a really big list 259s doesn't run out of stack 259s on [] 259s preserves the original 259s returns [] 259s on ["A"] 259s preserves the original 259s returns ["A"] 259s on ["A", "B", "C"] 259s preserves the original 259s returns ["C", "B", "A"] 259s 259s Hamster::List 259s #rotate 259s when passed no argument 259s returns a new list with the first element moved to the end 259s with an integral argument n 259s returns a new list with the first (n % size) elements moved to the end 259s with a non-numeric argument 259s raises a TypeError 259s with an argument of zero (or one evenly divisible by list length) 259s it returns self 259s 259s Hamster::List 259s #sample 259s returns a randomly chosen item 259s 259s Hamster::List 259s #select 259s is lazy 259s with an empty array 259s with a block 259s preserves the original 259s returns the selected list 259s without a block 259s returns an Enumerator 259s with a single item array 259s with a block 259s preserves the original 259s returns the selected list 259s without a block 259s returns an Enumerator 259s with a multi-item array 259s with a block 259s preserves the original 259s returns the selected list 259s without a block 259s returns an Enumerator 259s with a multi-item single selectable array 259s with a block 259s preserves the original 259s returns the selected list 259s without a block 259s returns an Enumerator 259s with a multi-item multi-selectable array 259s with a block 259s preserves the original 259s returns the selected list 259s without a block 259s returns an Enumerator 259s 259s Hamster::List 259s #size 259s on a really big list 259s doesn't run out of stack 259s on [] 259s returns 0 259s on ["A"] 259s returns 1 259s on ["A", "B", "C"] 259s returns 3 259s #length 259s on a really big list 259s doesn't run out of stack 259s on [] 259s returns 0 259s on ["A"] 259s returns 1 259s on ["A", "B", "C"] 259s returns 3 259s 259s Hamster::List 259s #slice 259s when passed a positive integral index 259s returns the element at that index 259s leaves the original unchanged 259s when passed a negative integral index 259s returns the element which is number (index.abs) counting from the end of the list 259s when passed a positive integral index and count 259s returns 'count' elements starting from 'index' 259s leaves the original unchanged 259s when passed a negative integral index and count 259s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 259s when passed a Range 259s returns the elements whose indexes are within the given Range 259s leaves the original unchanged 259s when passed a subclass of Range 259s works the same as with a Range 259s #[] 259s when passed a positive integral index 259s returns the element at that index 259s leaves the original unchanged 259s when passed a negative integral index 259s returns the element which is number (index.abs) counting from the end of the list 259s when passed a positive integral index and count 259s returns 'count' elements starting from 'index' 259s leaves the original unchanged 259s when passed a negative integral index and count 259s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 259s when passed a Range 259s returns the elements whose indexes are within the given Range 259s leaves the original unchanged 259s when passed a subclass of Range 259s works the same as with a Range 259s 259s Hamster::List 259s #sort 259s is lazy 259s on [] 259s with a block 259s preserves the original 259s returns [] 259s without a block 259s preserves the original 259s returns [] 259s on ["A"] 259s with a block 259s preserves the original 259s returns ["A"] 259s without a block 259s preserves the original 259s returns ["A"] 259s on ["Ichi", "Ni", "San"] 259s with a block 259s preserves the original 259s returns ["Ni", "San", "Ichi"] 259s without a block 259s preserves the original 259s returns ["Ichi", "Ni", "San"] 259s #sort_by 259s is lazy 259s on [] 259s with a block 259s preserves the original 259s returns [] 259s without a block 259s preserves the original 259s returns [] 259s on ["A"] 259s with a block 259s preserves the original 259s returns ["A"] 259s without a block 259s preserves the original 259s returns ["A"] 259s on ["Ichi", "Ni", "San"] 259s with a block 259s preserves the original 259s returns ["Ni", "San", "Ichi"] 259s without a block 259s preserves the original 259s returns ["Ichi", "Ni", "San"] 259s 259s Hamster::list#span 259s is lazy 259s given a predicate (in the form of a block), splits the list into two lists 259s (returned as an array) such that elements in the first list (the prefix) are 259s taken from the head of the list while the predicate is satisfied, and elements 259s in the second list (the remainder) are the remaining elements from the list 259s once the predicate is not satisfied. For example: 259s given the list [] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [] 259s returns the remainder as [] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [1] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [1] 259s returns the remainder as [] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [1, 2] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [1, 2] 259s returns the remainder as [] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [1, 2, 3] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [1, 2] 259s returns the remainder as [3] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [1, 2, 3, 4] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [1, 2] 259s returns the remainder as [3, 4] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [2, 3, 4] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [2] 259s returns the remainder as [3, 4] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [3, 4] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [] 259s returns the remainder as [3, 4] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s given the list [4] 259s and a predicate that returns true for values <= 2 259s preserves the original 259s returns the prefix as [] 259s returns the remainder as [4] 259s calls the block only once for each element 259s without a predicate 259s returns a frozen array 259s returns self as the prefix 259s returns an empty list as the remainder 259s 259s Hamster::List 259s #split_at 259s is lazy 259s on [] 259s preserves the original 259s returns a frozen array with two items 259s correctly identifies the matches 259s correctly identifies the remainder 259s on [1] 259s preserves the original 259s returns a frozen array with two items 259s correctly identifies the matches 259s correctly identifies the remainder 259s on [1, 2] 259s preserves the original 259s returns a frozen array with two items 259s correctly identifies the matches 259s correctly identifies the remainder 259s on [1, 2, 3] 259s preserves the original 259s returns a frozen array with two items 259s correctly identifies the matches 259s correctly identifies the remainder 259s on [1, 2, 3, 4] 259s preserves the original 259s returns a frozen array with two items 259s correctly identifies the matches 259s correctly identifies the remainder 259s 259s Hamster::List 259s #subsequences 259s yields all sublists with 1 or more consecutive items 259s with no block 259s returns an Enumerator 259s 259s Hamster::List 259s #sum 259s on a really big list 259s doesn't run out of stack 259s on [] 259s returns 0 259s on [2] 259s returns 2 259s on [1, 3, 5, 7, 11] 259s returns 27 259s 259s Hamster::List 259s #tail 259s on a really big list 259s doesn't run out of stack 259s on [] 259s preserves the original 259s returns [] 259s on ["A"] 259s preserves the original 259s returns [] 259s on ["A", "B", "C"] 259s preserves the original 259s returns ["B", "C"] 259s 259s Hamster::List 259s #tails 259s is lazy 259s on [] 259s preserves the original 259s returns [] 259s on ["A"] 259s preserves the original 259s returns [Hamster::List["A"]] 259s on ["A", "B", "C"] 259s preserves the original 259s returns [Hamster::List["A", "B", "C"], Hamster::List["B", "C"], Hamster::List["C"]] 259s 259s Hamster::List 259s #take 259s is lazy 259s 10 from [] 259s preserves the original 259s returns [] 259s 10 from ["A"] 259s preserves the original 259s returns ["A"] 259s -1 from ["A"] 259s preserves the original 259s returns [] 259s 0 from ["A", "B", "C"] 259s preserves the original 259s returns [] 259s 2 from ["A", "B", "C"] 259s preserves the original 259s returns ["A", "B"] 259s 259s Hamster::List 259s #take_while 259s is lazy 259s on [] 259s with a block 259s returns [] 259s preserves the original 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A"] 259s with a block 259s returns ["A"] 259s preserves the original 259s is lazy 259s without a block 259s returns an Enumerator 259s on ["A", "B", "C"] 259s with a block 259s returns ["A", "B"] 259s preserves the original 259s is lazy 259s without a block 259s returns an Enumerator 259s 259s Hamster::List 259s #to_a 259s on a really big list 259s doesn't run out of stack 259s on [] 259s returns [] 259s leaves the original unchanged 259s returns a mutable array 259s on ["A"] 259s returns ["A"] 259s leaves the original unchanged 259s returns a mutable array 259s on ["A", "B", "C"] 259s returns ["A", "B", "C"] 259s leaves the original unchanged 259s returns a mutable array 259s #entries 259s on a really big list 259s doesn't run out of stack 259s on [] 259s returns [] 259s leaves the original unchanged 259s returns a mutable array 259s on ["A"] 259s returns ["A"] 259s leaves the original unchanged 259s returns a mutable array 259s on ["A", "B", "C"] 259s returns ["A", "B", "C"] 259s leaves the original unchanged 259s returns a mutable array 259s 259s Hamster::List 259s #to_ary 259s on a really big list 259s doesn't run out of stack 259s enables implicit conversion to 259s block parameters 259s method arguments 259s works with splat 259s 259s Hamster::List 259s #to_list 259s on [] 259s returns self 259s on ["A"] 259s returns self 259s on ["A", "B", "C"] 259s returns self 259s 259s Hamster::List 259s #to_set 259s on [] 259s returns a set with the same values 259s on ["A"] 259s returns a set with the same values 259s on ["A", "B", "C"] 259s returns a set with the same values 259s 259s Hamster::List 259s #transpose 259s takes a list of lists and returns a list of all the first elements, all the 2nd elements, and so on 259s only goes as far as the shortest list 259s 259s Hamster::List 259s #union 259s is lazy 259s returns [] 259s for [] and [] 259s for [] and [] 259s returns ["A"] 259s for ["A"] and [] 259s for [] and ["A"] 259s returns ["A", "B", "C"] 259s for ["A", "B", "C"] and [] 259s for [] and ["A", "B", "C"] 259s returns ["A"] 259s for ["A", "A"] and ["A"] 259s for ["A"] and ["A", "A"] 259s #| 259s is lazy 259s returns [] 259s for [] and [] 259s for [] and [] 259s returns ["A"] 259s for ["A"] and [] 259s for [] and ["A"] 259s returns ["A", "B", "C"] 259s for ["A", "B", "C"] and [] 259s for [] and ["A", "B", "C"] 259s returns ["A"] 259s for ["A", "A"] and ["A"] 259s for ["A"] and ["A", "A"] 259s 259s Hamster::List 259s #uniq 259s is lazy 259s when passed a block 259s uses the block to identify duplicates 259s on [] 259s preserves the original 259s returns [] 259s on ["A"] 259s preserves the original 259s returns ["A"] 259s on ["A", "B", "C"] 259s preserves the original 259s returns ["A", "B", "C"] 259s on ["A", "B", "A", "C", "C"] 259s preserves the original 259s returns ["A", "B", "C"] 259s 259s Hamster::List 259s #zip 259s is lazy 259s on [] and [] 259s returns [] 259s on ["A"] and ["aye"] 259s returns [Hamster::List["A", "aye"]] 259s on ["A"] and [] 259s returns [Hamster::List["A", nil]] 259s on [] and ["A"] 259s returns [Hamster::List[nil, "A"]] 259s on ["A", "B", "C"] and ["aye", "bee", "see"] 259s returns [Hamster::List["A", "aye"], Hamster::List["B", "bee"], Hamster::List["C", "see"]] 259s 259s Hamster 259s .from 259s with {"a"=>1, "b"=>[2, {"c"=>3}, 4], "d"=>#, "e"=>{"f"=>8, "g"=>9}, "h"=>/ijk/} as input 259s should return Hamster::Hash["e" => Hamster::Hash["g" => 9, "f" => 8], "a" => 1, "b" => Hamster::Vector[2, Hamster::Hash["c" => 3], 4], "d" => Hamster::Set[6, 5, 7], "h" => /ijk/] 259s with {} as input 259s should return Hamster::Hash[] 259s with {"a"=>1, "b"=>2, "c"=>3} as input 259s should return Hamster::Hash["a" => 1, "b" => 2, "c" => 3] 259s with [] as input 259s should return Hamster::Vector[] 259s with [1, 2, 3] as input 259s should return Hamster::Vector[1, 2, 3] 259s with # as input 259s should return Hamster::Set[] 259s with # as input 259s should return Hamster::Set[2, 3, 1] 259s with 42 as input 259s should return 42 259s with #> as input 259s should return #> 259s with # as input 259s should return Hamster::Hash[:address => nil, :name => nil] 259s with # as input 259s should return Hamster::Hash[:address => "123 Main", :name => "Dave"] 259s with mixed object 259s should return Hamster data 259s .to_ruby 259s with Hamster::Hash["e" => Hamster::Hash["g" => 9, "f" => 8], "a" => 1, "b" => Hamster::Vector[2, Hamster::Hash["c" => 3], 4], "d" => Hamster::Set[6, 5, 7], "h" => /ijk/] as input 259s should return {"a"=>1, "b"=>[2, {"c"=>3}, 4], "d"=>#, "e"=>{"f"=>8, "g"=>9}, "h"=>/ijk/} (PENDING: Temporarily skipped with xit) 259s with Hamster::Hash[] as input 259s should return {} (PENDING: Temporarily skipped with xit) 259s with Hamster::Hash["a" => 1, "b" => 2, "c" => 3] as input 259s should return {"a"=>1, "b"=>2, "c"=>3} (PENDING: Temporarily skipped with xit) 259s with Hamster::Vector[] as input 259s should return [] (PENDING: Temporarily skipped with xit) 259s with Hamster::Vector[1, 2, 3] as input 259s should return [1, 2, 3] (PENDING: Temporarily skipped with xit) 259s with Hamster::Set[] as input 259s should return # (PENDING: Temporarily skipped with xit) 259s with Hamster::Set[2, 3, 1] as input 259s should return # (PENDING: Temporarily skipped with xit) 259s with 42 as input 259s should return 42 (PENDING: Temporarily skipped with xit) 259s with #> as input 259s should return #> (PENDING: Temporarily skipped with xit) 259s with Hamster::Deque[] as input 259s should return [] 259s with Hamster::Deque[Hamster::Hash["a" => 1]] as input 259s should return [{"a" => 1}] 259s with Hamster::SortedSet[] as input 259s should return ::SortedSet.new 259s with Hamster::SortedSet[1, 2, 3] as input 259s should return ::SortedSet.new 259s with mixed object 259s should return Ruby data structures 259s 259s Hamster::Set 259s #add 259s can add nil to a set 259s works on large sets, with many combinations of input 259s with a unique value 259s preserves the original 259s returns a copy with the superset of values 259s with a duplicate value 259s preserves the original values 259s returns self 259s #<< 259s can add nil to a set 259s works on large sets, with many combinations of input 259s with a unique value 259s preserves the original 259s returns a copy with the superset of values 259s with a duplicate value 259s preserves the original values 259s returns self 259s #add? 259s with a unique value 259s preserves the original 259s returns a copy with the superset of values 259s with a duplicate value 259s preserves the original values 259s returns false 259s 259s Hamster::Set 259s #all? 259s when empty 259s with a block returns true 259s with no block returns true 259s when not empty 259s with a block 259s returns true if the block always returns true 259s returns false if the block ever returns false 259s propagates an exception from the block 259s stops iterating as soon as the block returns false 259s with no block 259s returns true if all values are truthy 259s returns false if any value is nil 259s returns false if any value is false 259s 259s Hamster::Set 259s #any? 259s when empty 259s with a block returns false 259s with no block returns false 259s when not empty 259s with a block 259s returns true if the block ever returns true ("A") 259s returns true if the block ever returns true ("B") 259s returns true if the block ever returns true ("C") 259s returns true if the block ever returns true (nil) 259s returns false if the block always returns false 259s propagates exceptions raised in the block 259s stops iterating as soon as the block returns true 259s with no block 259s returns true if any value is truthy 259s returns false if all values are falsey 259s 259s Hamster::Set 259s #clear 259s on [] 259s preserves the original 259s returns an empty set 259s on ["A"] 259s preserves the original 259s returns an empty set 259s on ["A", "B", "C"] 259s preserves the original 259s returns an empty set 259s from a subclass 259s returns an empty instance of the subclass 259s 259s Hamster::Set 259s #compact 259s on [] 259s preserves the original 259s returns [] 259s on ["A"] 259s preserves the original 259s returns ["A"] 259s on ["A", "B", "C"] 259s preserves the original 259s returns ["A", "B", "C"] 259s on [nil] 259s preserves the original 259s returns [] 259s on [nil, "B"] 259s preserves the original 259s returns ["B"] 259s on ["A", nil] 259s preserves the original 259s returns ["A"] 259s on [nil, nil] 259s preserves the original 259s returns [] 259s on ["A", nil, "C"] 259s preserves the original 259s returns ["A", "C"] 259s on [nil, "B", nil] 259s preserves the original 259s returns ["B"] 259s 259s Hamster::Set 259s .set 259s with no values 259s returns the empty set 259s with a list of values 259s is equivalent to repeatedly using #add 259s 259s Hamster::Set 259s #dup 259s returns self 259s #clone 259s returns self 259s 259s Hamster::Set 259s #count 259s works on large sets 259s on [] 259s with a block 259s returns 0 259s without a block 259s returns length 259s on [1] 259s with a block 259s returns 1 259s without a block 259s returns length 259s on [1, 2] 259s with a block 259s returns 1 259s without a block 259s returns length 259s on [1, 2, 3] 259s with a block 259s returns 2 259s without a block 259s returns length 259s on [1, 2, 3, 4] 259s with a block 259s returns 2 259s without a block 259s returns length 259s on [1, 2, 3, 4, 5] 259s with a block 259s returns 3 259s without a block 259s returns length 259s 259s Hamster::Set 259s #delete 259s works on large sets, with many combinations of input 259s with an existing value 259s preserves the original 259s returns a copy with the remaining values 259s with a non-existing value 259s preserves the original values 259s returns self 259s when removing the last value in a set 259s returns the canonical empty set 259s #delete? 259s with an existing value 259s preserves the original 259s returns a copy with the remaining values 259s with a non-existing value 259s preserves the original values 259s returns false 259s 259s Hamster::Set 259s #difference 260s works on a wide variety of inputs 260s for [] and [] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s doesn't modify the original Sets 260s returns ["A"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s doesn't modify the original Sets 260s returns ["A", "C"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["A", "C"] 260s doesn't modify the original Sets 260s returns ["B"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C", "D", "E", "F", "G", "H"] and [] 260s doesn't modify the original Sets 260s returns ["A", "B", "C", "D", "E", "F", "G", "H"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C", "M", "X", "Y", "Z"] and ["B", "C", "D", "E", "F", "G", "H", "I", "J", "X"] 260s doesn't modify the original Sets 260s returns ["A", "M", "Y", "Z"] 260s when passed a Ruby Array 260s returns the expected Set 260s #subtract 260s works on a wide variety of inputs 260s for [] and [] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s doesn't modify the original Sets 260s returns ["A"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s doesn't modify the original Sets 260s returns ["A", "C"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["A", "C"] 260s doesn't modify the original Sets 260s returns ["B"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C", "D", "E", "F", "G", "H"] and [] 260s doesn't modify the original Sets 260s returns ["A", "B", "C", "D", "E", "F", "G", "H"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C", "M", "X", "Y", "Z"] and ["B", "C", "D", "E", "F", "G", "H", "I", "J", "X"] 260s doesn't modify the original Sets 260s returns ["A", "M", "Y", "Z"] 260s when passed a Ruby Array 260s returns the expected Set 260s #- 260s works on a wide variety of inputs 260s for [] and [] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s doesn't modify the original Sets 260s returns ["A"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s doesn't modify the original Sets 260s returns ["A", "C"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["A", "C"] 260s doesn't modify the original Sets 260s returns ["B"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C", "D", "E", "F", "G", "H"] and [] 260s doesn't modify the original Sets 260s returns ["A", "B", "C", "D", "E", "F", "G", "H"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C", "M", "X", "Y", "Z"] and ["B", "C", "D", "E", "F", "G", "H", "I", "J", "X"] 260s doesn't modify the original Sets 260s returns ["A", "M", "Y", "Z"] 260s when passed a Ruby Array 260s returns the expected Set 260s 260s Hamster::Set 260s #disjoint? 260s for [] and [] 260s returns true 260s for ["A"] and [] 260s returns true 260s for [] and ["A"] 260s returns true 260s for ["A"] and ["A"] 260s returns false 260s for ["A", "B", "C"] and ["B"] 260s returns false 260s for ["B"] and ["A", "B", "C"] 260s returns false 260s for ["A", "B", "C"] and ["D", "E"] 260s returns true 260s for ["F", "G", "H", "I"] and ["A", "B", "C"] 260s returns true 260s for ["A", "B", "C"] and ["A", "B", "C"] 260s returns false 260s for ["A", "B", "C"] and ["A", "B", "C", "D"] 260s returns false 260s for ["D", "E", "F", "G"] and ["A", "B", "C"] 260s returns true 260s 260s Hamster::Set 260s #each 260s yields both of a pair of colliding keys 260s without a block 260s returns an Enumerator 260s with an empty block 260s returns self 260s with a block 260s yields all values 260s 260s Hamster::Set 260s #empty? 260s on [] 260s returns true 260s on ["A"] 260s returns false 260s on ["A", "B", "C"] 260s returns false 260s on [nil] 260s returns false 260s on [false] 260s returns false 260s .empty 260s returns the canonical empty set 260s from a subclass 260s returns an empty instance of the subclass 260s calls overridden #initialize when creating empty Set 260s 260s Hamster::Set 260s #== 260s when comparing to a standard set 260s returns false 260s when comparing to a arbitrary object 260s returns false 260s with an empty set for each comparison 260s returns true 260s with an empty set and a set with nil 260s returns false 260s with a single item array and empty array 260s returns false 260s with matching single item array 260s returns true 260s with mismatching single item array 260s returns false 260s with a multi-item array and single item array 260s returns false 260s with matching multi-item array 260s returns true 260s with a mismatching multi-item array 260s returns true 260s 260s Hamster::Set 260s #eql? 260s when comparing to a standard set 260s returns false 260s when comparing to a arbitrary object 260s returns false 260s when comparing with a subclass of Hamster::Set 260s returns false 260s with an empty set for each comparison 260s returns true 260s with an empty set and a set with nil 260s returns false 260s with a single item array and empty array 260s returns false 260s with matching single item array 260s returns true 260s with mismatching single item array 260s returns false 260s with a multi-item array and single item array 260s returns false 260s with matching multi-item array 260s returns true 260s with a mismatching multi-item array 260s returns true 260s 260s Hamster::Set 260s #exclusion 260s works for a wide variety of inputs 260s for [] and [] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s doesn't modify the original Sets 260s returns ["A"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s doesn't modify the original Sets 260s returns ["A", "C"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B", "C", "D"] 260s doesn't modify the original Sets 260s returns ["A", "D"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["D", "E", "F"] 260s doesn't modify the original Sets 260s returns ["A", "B", "C", "D", "E", "F"] 260s when passed a Ruby Array 260s returns the expected Set 260s #^ 260s works for a wide variety of inputs 260s for [] and [] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s doesn't modify the original Sets 260s returns ["A"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s doesn't modify the original Sets 260s returns [] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s doesn't modify the original Sets 260s returns ["A", "C"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B", "C", "D"] 260s doesn't modify the original Sets 260s returns ["A", "D"] 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["D", "E", "F"] 260s doesn't modify the original Sets 260s returns ["A", "B", "C", "D", "E", "F"] 260s when passed a Ruby Array 260s returns the expected Set 260s 260s Hamster::Set 260s #find 260s on [] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on [] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A"] 260s with a block 260s returns "A" 260s without a block 260s returns an Enumerator 260s on ["A"] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A"] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns "A" 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns "B" 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s #detect 260s on [] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on [] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A"] 260s with a block 260s returns "A" 260s without a block 260s returns an Enumerator 260s on ["A"] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A"] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns "A" 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns "B" 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s on ["A", "B", nil] 260s with a block 260s returns nil 260s without a block 260s returns an Enumerator 260s 260s Hamster::Set 260s #first 260s returns nil if only member of set is nil 260s returns the first item yielded by #each 260s on an empty set 260s returns nil 260s on a non-empty set 260s returns an arbitrary value from the set 260s 260s Hamster 260s #flatten 260s on ["A"] 260s preserves the original 260s returns the inlined values 260s on ["A", "B", "C"] 260s preserves the original 260s returns the inlined values 260s on ["A", Hamster::Set["B"], "C"] 260s preserves the original 260s returns the inlined values 260s on [Hamster::Set["A"], Hamster::Set["B"], Hamster::Set["C"]] 260s preserves the original 260s returns the inlined values 260s on an empty set 260s returns an empty set 260s on a set with multiple levels of nesting 260s inlines lower levels of nesting 260s from a subclass 260s returns an instance of the subclass 260s 260s Hamster::Set 260s #grep 260s without a block 260s with an empty set 260s returns the filtered values 260s with a single item set 260s returns the filtered values 260s with a single item set that doesn't contain match 260s returns the filtered values 260s with a multi-item set where one isn't a match 260s returns the filtered values 260s with a block 260s processes each matching item with the block 260s returns the filtered values 260s 260s Hamster::Set 260s #grep_v 260s without a block 260s with an empty set 260s returns the filtered values 260s with a single item set 260s returns the filtered values 260s with a single item set that doesn't contain match 260s returns the filtered values 260s with a multi-item set where one isn't a match 260s returns the filtered values 260s with a block 260s resulting items are processed with the block 260s returns the filtered values 260s 260s Hamster::Set 260s #group_by 260s returns a hash without default proc 260s with a block 260s on [] 260s returns [] 260s on [1] 260s returns [{true=>Hamster::Set[1]}] 260s on [1, 2, 3, 4] 260s returns [{true=>Hamster::Set[3, 1], false=>Hamster::Set[4, 2]}] 260s without a block 260s on [] 260s returns [] 260s on [1] 260s returns [{1=>Hamster::Set[1]}] 260s on [1, 2, 3, 4] 260s returns [{1=>Hamster::Set[1], 2=>Hamster::Set[2], 3=>Hamster::Set[3], 4=>Hamster::Set[4]}] 260s on an empty set 260s returns an empty hash 260s from a subclass 260s returns an Hash whose values are instances of the subclass 260s #group 260s returns a hash without default proc 260s with a block 260s on [] 260s returns [] 260s on [1] 260s returns [{true=>Hamster::Set[1]}] 260s on [1, 2, 3, 4] 260s returns [{true=>Hamster::Set[3, 1], false=>Hamster::Set[4, 2]}] 260s without a block 260s on [] 260s returns [] 260s on [1] 260s returns [{1=>Hamster::Set[1]}] 260s on [1, 2, 3, 4] 260s returns [{1=>Hamster::Set[1], 2=>Hamster::Set[2], 3=>Hamster::Set[3], 4=>Hamster::Set[4]}] 260s on an empty set 260s returns an empty hash 260s from a subclass 260s returns an Hash whose values are instances of the subclass 260s #classify 260s returns a hash without default proc 260s with a block 260s on [] 260s returns [] 260s on [1] 260s returns [{true=>Hamster::Set[1]}] 260s on [1, 2, 3, 4] 260s returns [{true=>Hamster::Set[3, 1], false=>Hamster::Set[4, 2]}] 260s without a block 260s on [] 260s returns [] 260s on [1] 260s returns [{1=>Hamster::Set[1]}] 260s on [1, 2, 3, 4] 260s returns [{1=>Hamster::Set[1], 2=>Hamster::Set[2], 3=>Hamster::Set[3], 4=>Hamster::Set[4]}] 260s on an empty set 260s returns an empty hash 260s from a subclass 260s returns an Hash whose values are instances of the subclass 260s 260s Hamster::Set 260s #hash 260s generates the same hash value for a set regardless of the order things were added to it 260s values are sufficiently distributed 260s on an empty set 260s returns 0 260s 260s Hamster::Set 260s includes Immutable 260s 260s Hamster::Set 260s #include? 260s returns true for an existing value ("A") 260s returns true for an existing value ("B") 260s returns true for an existing value ("C") 260s returns true for an existing value (2.0) 260s returns true for an existing value (nil) 260s returns false for a non-existing value 260s returns true even if existing value is nil 260s returns true even if existing value is false 260s returns false for a mutable item which is mutated after adding 260s uses #eql? for equality 260s returns the right answers after a lot of addings and removings 260s #member? 260s returns true for an existing value ("A") 260s returns true for an existing value ("B") 260s returns true for an existing value ("C") 260s returns true for an existing value (2.0) 260s returns true for an existing value (nil) 260s returns false for a non-existing value 260s returns true even if existing value is nil 260s returns true even if existing value is false 260s returns false for a mutable item which is mutated after adding 260s uses #eql? for equality 260s returns the right answers after a lot of addings and removings 260s 260s Hamster::Set 260s #inspect 260s on [] 260s returns "Hamster::Set[]" 260s returns a string which can be eval'd to get an equivalent set 260s on ["A"] 260s returns "Hamster::Set[\"A\"]" 260s returns a string which can be eval'd to get an equivalent set 260s on ["A", "B", "C"] 260s returns a programmer-readable representation of the set contents 260s returns a string which can be eval'd to get an equivalent set 260s from a subclass 260s returns a programmer-readable representation of the set contents 260s returns a string which can be eval'd to get an equivalent set 260s 260s Hamster::Set 260s #intersect? 260s for [] and [] 260s returns false 260s for ["A"] and [] 260s returns false 260s for [] and ["A"] 260s returns false 260s for ["A"] and ["A"] 260s returns true 260s for ["A", "B", "C"] and ["B"] 260s returns true 260s for ["B"] and ["A", "B", "C"] 260s returns true 260s for ["A", "B", "C"] and ["D", "E"] 260s returns false 260s for ["F", "G", "H", "I"] and ["A", "B", "C"] 260s returns false 260s for ["A", "B", "C"] and ["A", "B", "C"] 260s returns true 260s for ["A", "B", "C"] and ["A", "B", "C", "D"] 260s returns true 260s for ["D", "E", "F", "G"] and ["A", "B", "C"] 260s returns false 260s 260s Hamster::Set 260s #intersection 260s returns results consistent with Array#& 260s for [] and [] 260s returns [], without changing the original Sets 260s for [] and [] 260s returns [], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s returns [], without changing the original Sets 260s for [] and ["A"] 260s returns [], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s returns ["A"], without changing the original Sets 260s for ["A"] and ["A"] 260s returns ["A"], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s returns ["B"], without changing the original Sets 260s for ["B"] and ["A", "B", "C"] 260s returns ["B"], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["A", "C"] 260s returns ["A", "C"], without changing the original Sets 260s for ["A", "C"] and ["A", "B", "C"] 260s returns ["A", "C"], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s #& 260s returns results consistent with Array#& 260s for [] and [] 260s returns [], without changing the original Sets 260s for [] and [] 260s returns [], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and [] 260s returns [], without changing the original Sets 260s for [] and ["A"] 260s returns [], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A"] and ["A"] 260s returns ["A"], without changing the original Sets 260s for ["A"] and ["A"] 260s returns ["A"], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["B"] 260s returns ["B"], without changing the original Sets 260s for ["B"] and ["A", "B", "C"] 260s returns ["B"], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s for ["A", "B", "C"] and ["A", "C"] 260s returns ["A", "C"], without changing the original Sets 260s for ["A", "C"] and ["A", "B", "C"] 260s returns ["A", "C"], without changing the original Sets 260s when passed a Ruby Array 260s returns the expected Set 260s 260s Hamster::Set 260s #join 260s with a separator 260s on [] 260s preserves the original 260s returns "" 260s on ["A"] 260s preserves the original 260s returns "A" 260s on ["A", "B", "C"] 260s preserves the original 260s returns "A|B|C" 260s without a separator 260s on [] 260s preserves the original 260s returns "" 260s on ["A"] 260s preserves the original 260s returns "A" 260s on ["A", "B", "C"] 260s preserves the original 260s returns "ABC" 260s without a separator (with global default separator set) 260s on ['A', 'B', 'C'] 260s preserves the original 260s returns nil 260s 260s Hamster::Set 260s #map 260s works on large sets 260s when empty 260s returns self 260s when not empty 260s with a block 260s preserves the original values 260s returns a new set with the mapped values 260s with no block 260s returns an Enumerator 260s from a subclass 260s returns an instance of the subclass 260s when multiple items map to the same value 260s filters out the duplicates 260s #collect 260s works on large sets 260s when empty 260s returns self 260s when not empty 260s with a block 260s preserves the original values 260s returns a new set with the mapped values 260s with no block 260s returns an Enumerator 260s from a subclass 260s returns an instance of the subclass 260s when multiple items map to the same value 260s filters out the duplicates 260s 260s Hamster::Set 260s #marshal_dump/#marshal_load 260s can survive dumping and loading into a new process 260s is still possible to test items by key after loading 260s 260s Hamster::Set 260s #max 260s with a block 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "Ichi" 260s without a block 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "San" 260s 260s Hamster::Set 260s #min 260s with a block 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "Ni" 260s without a block 260s on [] 260s returns nil 260s on ["A"] 260s returns "A" 260s on ["Ichi", "Ni", "San"] 260s returns "Ichi" 260s 260s Hamster::Set 260s .new 260s initializes a new set 260s accepts a Range 260s returns a Set which doesn't change even if the initializer is mutated 260s is amenable to overriding of #initialize 260s from a subclass 260s returns a frozen instance of the subclass 260s [] 260s accepts any number of arguments and initializes a new set 260s 260s Hamster::Set 260s #none? 260s when empty 260s with a block returns true 261s with no block returns true 261s when not empty 261s with a block 261s returns false if the block ever returns true ("A") 261s returns false if the block ever returns true ("B") 261s returns false if the block ever returns true ("C") 261s returns false if the block ever returns true (nil) 261s returns true if the block always returns false 261s stops iterating as soon as the block returns true 261s with no block 261s returns false if any value is truthy 261s returns true if all values are falsey 261s 261s Hamster::Set 261s #one? 261s when empty 261s with a block returns false 261s with no block returns false 261s when not empty 261s with a block 261s returns false if the block returns true more than once 261s returns false if the block never returns true 261s returns true if the block only returns true once 261s with no block 261s returns false if more than one value is truthy 261s returns true if only one value is truthy 261s returns false if no values are truthy 261s 261s Hamster::Set 261s #partition 261s on [] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [1] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [1, 2] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [1, 2, 3] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [1, 2, 3, 4] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [2, 3, 4] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [3, 4] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s on [4] 261s with a block 261s preserves the original 261s returns a frozen array with two items 261s correctly identifies the matches 261s correctly identifies the remainder 261s without a block 261s returns an Enumerator 261s 261s Hamster::Set 261s #product 261s on [] 261s returns 1 261s doesn't change the original Set 261s on [2] 261s returns 2 261s doesn't change the original Set 261s on [1, 3, 5, 7, 11] 261s returns 1155 261s doesn't change the original Set 261s 261s Hamster::Set 261s #reduce 261s on [] 261s with an initial value of 10 261s and a block 261s returns 10 261s on [1] 261s with an initial value of 10 261s and a block 261s returns 9 261s on [1, 2, 3] 261s with an initial value of 10 261s and a block 261s returns 4 261s on [] 261s with no initial value 261s and a block 261s returns nil 261s on [1] 261s with no initial value 261s and a block 261s returns 1 261s on [1, 2, 3] 261s with no initial value 261s and a block 261s returns 6 261s with no block and a symbol argument 261s uses the symbol as the name of a method to reduce with 261s with no block and a string argument 261s uses the string as the name of a method to reduce with 261s #inject 261s on [] 261s with an initial value of 10 261s and a block 261s returns 10 261s on [1] 261s with an initial value of 10 261s and a block 261s returns 9 261s on [1, 2, 3] 261s with an initial value of 10 261s and a block 261s returns 4 261s on [] 261s with no initial value 261s and a block 261s returns nil 261s on [1] 261s with no initial value 261s and a block 261s returns 1 261s on [1, 2, 3] 261s with no initial value 261s and a block 261s returns 6 261s with no block and a symbol argument 261s uses the symbol as the name of a method to reduce with 261s with no block and a string argument 261s uses the string as the name of a method to reduce with 261s 261s Hamster::Set 261s #reject 261s when nothing matches 261s returns self 261s when only some things match 261s with a block 261s preserves the original 261s returns a set with the matching values 261s with no block 261s returns self 261s on a large set, with many combinations of input 261s still works 261s #delete_if 261s when nothing matches 261s returns self 261s when only some things match 261s with a block 261s preserves the original 261s returns a set with the matching values 261s with no block 261s returns self 261s on a large set, with many combinations of input 261s still works 261s 261s Hamster::Set 261s #reverse_each 261s without a block 261s returns an Enumerator 261s with an empty block 261s returns self 261s with a block 261s yields all values 261s 261s Hamster::Set 261s #sample 261s returns a randomly chosen item 261s 261s Hamster::Set 261s #select 261s works on a large set, with many combinations of input 261s when everything matches 261s returns self 261s when only some things match 261s with a block 261s preserves the original 261s returns a set with the matching values 261s with no block 261s returns an Enumerator 261s when nothing matches 261s preserves the original 261s returns the canonical empty set 261s from a subclass 261s returns an instance of the same class 261s #find_all 261s works on a large set, with many combinations of input 261s when everything matches 261s returns self 261s when only some things match 261s with a block 261s preserves the original 261s returns a set with the matching values 261s with no block 261s returns an Enumerator 261s when nothing matches 261s preserves the original 261s returns the canonical empty set 261s from a subclass 261s returns an instance of the same class 261s 261s Hamster::Set 261s #size 261s returns 0 for [] 261s returns 1 for ["A"] 261s returns 3 for ["A", "B", "C"] 261s #length 261s returns 0 for [] 261s returns 1 for ["A"] 261s returns 3 for ["A", "B", "C"] 261s 261s Hamster::Set 261s #sort 261s on [] 261s with a block 261s returns [] 261s doesn't change the original Set 261s without a block 261s returns [] 261s doesn't change the original Set 261s on ["A"] 261s with a block 261s returns ["A"] 261s doesn't change the original Set 261s without a block 261s returns ["A"] 261s doesn't change the original Set 261s on ["Ichi", "Ni", "San"] 261s with a block 261s returns ["Ni", "San", "Ichi"] 261s doesn't change the original Set 261s without a block 261s returns ["Ichi", "Ni", "San"] 261s doesn't change the original Set 261s #sort_by 261s on [] 261s with a block 261s returns [] 261s doesn't change the original Set 261s without a block 261s returns [] 261s doesn't change the original Set 261s on ["A"] 261s with a block 261s returns ["A"] 261s doesn't change the original Set 261s without a block 261s returns ["A"] 261s doesn't change the original Set 261s on ["Ichi", "Ni", "San"] 261s with a block 261s returns ["Ni", "San", "Ichi"] 261s doesn't change the original Set 261s without a block 261s returns ["Ichi", "Ni", "San"] 261s doesn't change the original Set 261s #sort_by 261s only calls the passed block once for each item 261s 261s Hamster::Set 261s #subset? 261s for [] and [] 261s returns true 261s for ["A"] and [] 261s returns false 261s for [] and ["A"] 261s returns true 261s for ["A"] and ["A"] 261s returns true 261s for ["A", "B", "C"] and ["B"] 261s returns false 261s for ["B"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "C"] 261s returns false 261s for ["A", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns true 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns false 261s #<= 261s for [] and [] 261s returns true 261s for ["A"] and [] 261s returns false 261s for [] and ["A"] 261s returns true 261s for ["A"] and ["A"] 261s returns true 261s for ["A", "B", "C"] and ["B"] 261s returns false 261s for ["B"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "C"] 261s returns false 261s for ["A", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns true 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns false 261s #proper_subset? 261s for [] and [] 261s returns false 261s for ["A"] and [] 261s returns false 261s for [] and ["A"] 261s returns true 261s for ["A"] and ["A"] 261s returns false 261s for ["A", "B", "C"] and ["B"] 261s returns false 261s for ["B"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "C"] 261s returns false 261s for ["A", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns true 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns false 261s #< 261s for [] and [] 261s returns false 261s for ["A"] and [] 261s returns false 261s for [] and ["A"] 261s returns true 261s for ["A"] and ["A"] 261s returns false 261s for ["A", "B", "C"] and ["B"] 261s returns false 261s for ["B"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "C"] 261s returns false 261s for ["A", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns true 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns false 261s 261s Hamster::Set 261s #sum 261s on [] 261s returns 0 261s doesn't change the original Set 261s on [2] 261s returns 2 261s doesn't change the original Set 261s on [1, 3, 5, 7, 11] 261s returns 27 261s doesn't change the original Set 261s 261s Hamster::Set 261s #superset? 261s for [] and [] 261s returns true 261s for ["A"] and [] 261s returns true 261s for [] and ["A"] 261s returns false 261s for ["A"] and ["A"] 261s returns true 261s for ["A", "B", "C"] and ["B"] 261s returns true 261s for ["B"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "C"] 261s returns true 261s for ["A", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns false 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns true 261s #>= 261s for [] and [] 261s returns true 261s for ["A"] and [] 261s returns true 261s for [] and ["A"] 261s returns false 261s for ["A"] and ["A"] 261s returns true 261s for ["A", "B", "C"] and ["B"] 261s returns true 261s for ["B"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "C"] 261s returns true 261s for ["A", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns true 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns false 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns true 261s #proper_superset? 261s for [] and [] 261s returns false 261s for ["A"] and [] 261s returns true 261s for [] and ["A"] 261s returns false 261s for ["A"] and ["A"] 261s returns false 261s for ["A", "B", "C"] and ["B"] 261s returns true 261s for ["B"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "C"] 261s returns true 261s for ["A", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns false 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns true 261s #> 261s for [] and [] 261s returns false 261s for ["A"] and [] 261s returns true 261s for [] and ["A"] 261s returns false 261s for ["A"] and ["A"] 261s returns false 261s for ["A", "B", "C"] and ["B"] 261s returns true 261s for ["B"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "C"] 261s returns true 261s for ["A", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns false 261s for ["A", "B", "C"] and ["A", "B", "C", "D"] 261s returns false 261s for ["A", "B", "C", "D"] and ["A", "B", "C"] 261s returns true 261s 261s Hamster::Set 261s #to_a 261s on 'a'..'a' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'b' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'c' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'d' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'e' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'f' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'g' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'h' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'i' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'j' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'k' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'l' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'m' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'n' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'o' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'p' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'q' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'r' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'s' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'t' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'u' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'v' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'w' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'x' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'y' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'z' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s #entries 261s on 'a'..'a' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'b' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'c' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'d' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'e' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'f' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'g' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'h' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'i' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'j' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'k' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'l' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'m' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'n' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'o' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'p' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'q' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'r' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'s' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'t' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'u' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'v' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'w' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'x' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'y' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s on 'a'..'z' 261s returns an equivalent array 261s doesn't change the original Set 261s returns a mutable array 261s 261s Hamster::Set 261s #to_list 261s on [] 261s returns a list 261s doesn't change the original Set 261s the returned list 261s has the correct length 261s contains all values 261s on ["A"] 261s returns a list 261s doesn't change the original Set 261s the returned list 261s has the correct length 261s contains all values 261s on ["A", "B", "C"] 261s returns a list 261s doesn't change the original Set 261s the returned list 261s has the correct length 261s contains all values 261s 261s Hamster::Set 261s #to_set 261s on [] 261s returns self 261s on ["A"] 261s returns self 261s on ["A", "B", "C"] 261s returns self 261s 261s Hamster::Set 261s #union 261s for [] and [] 261s returns [], without changing the original Sets 261s for [] and [] 261s returns [], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"], without changing the original Sets 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["X", "Y", "Z"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s for ["X", "Y", "Z"] and ["A", "B", "C"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s when receiving a subset 261s returns self 261s #| 261s for [] and [] 261s returns [], without changing the original Sets 261s for [] and [] 261s returns [], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"], without changing the original Sets 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["X", "Y", "Z"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s for ["X", "Y", "Z"] and ["A", "B", "C"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s when receiving a subset 261s returns self 261s #+ 261s for [] and [] 261s returns [], without changing the original Sets 261s for [] and [] 261s returns [], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"], without changing the original Sets 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["X", "Y", "Z"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s for ["X", "Y", "Z"] and ["A", "B", "C"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s when receiving a subset 261s returns self 261s #merge 261s for [] and [] 261s returns [], without changing the original Sets 261s for [] and [] 261s returns [], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and ["A"] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for [] and ["A"] 261s returns ["A"], without changing the original Sets 261s for ["A"] and [] 261s returns ["A"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and [] 261s returns ["A", "B", "C"], without changing the original Sets 261s for [] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s for ["A", "B", "C"] and ["A", "B", "C"] 261s returns ["A", "B", "C"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s for ["A", "B", "C"] and ["X", "Y", "Z"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s for ["X", "Y", "Z"] and ["A", "B", "C"] 261s returns ["A", "B", "C", "X", "Y", "Z"], without changing the original Sets 261s when passed a Ruby Array 261s returns the expected Set 261s from a subclass 261s returns an instance of the subclass 261s when receiving a subset 261s returns self 261s 261s Hamster::SortedSet 261s #above 261s when called without a block 261s returns a sorted set of all items higher than the argument 261s when called with a block 261s yields all the items higher than the argument 261s on an empty set 261s returns an empty set 261s with an argument higher than all the values in the set 261s returns an empty set 262s 262s Hamster::SortedSet 262s #add 262s with a unique value 262s preserves the original 262s returns a copy with the superset of values (in order) 262s with a duplicate value 262s preserves the original values 262s returns self 262s on a set ordered by a comparator 262s inserts the new item in the correct place 262s #<< 262s with a unique value 262s preserves the original 262s returns a copy with the superset of values (in order) 262s with a duplicate value 262s preserves the original values 262s returns self 262s on a set ordered by a comparator 262s inserts the new item in the correct place 262s #add? 262s with a unique value 262s preserves the original 262s returns a copy with the superset of values 262s with a duplicate value 262s preserves the original values 262s returns false 262s 262s Hamster::SortedSet 262s #at 262s [] with 10 262s returns nil 262s ["A"] with 10 262s returns nil 262s ["A", "B", "C"] with 0 262s returns "A" 262s ["A", "B", "C"] with 1 262s returns "B" 262s ["A", "B", "C"] with 2 262s returns "C" 262s ["A", "B", "C"] with 3 262s returns nil 262s ["A", "B", "C"] with -1 262s returns "C" 262s ["A", "B", "C"] with -2 262s returns "B" 262s ["A", "B", "C"] with -3 262s returns "A" 262s ["A", "B", "C"] with -4 262s returns nil 262s 262s Hamster::SortedSet 262s #below 262s when called without a block 262s returns a sorted set of all items lower than the argument 262s when called with a block 262s yields all the items lower than the argument 262s on an empty set 262s returns an empty set 262s with an argument lower than all the values in the set 262s returns an empty set 262s 262s Hamster::SortedSet 262s #between 262s when called without a block 262s returns a sorted set of all items from the first argument to the second 262s when called with a block 262s yields all the items lower than the argument 262s on an empty set 262s returns an empty set 262s with a 'to' argument lower than the 'from' argument 262s returns an empty set 262s 262s Hamster::SortedSet 262s #clear 262s on [] 262s preserves the original 262s returns an empty set 262s on ["A"] 262s preserves the original 262s returns an empty set 262s on ["A", "B", "C"] 262s preserves the original 262s returns an empty set 262s from a subclass 262s returns an empty instance of the subclass 262s with a comparator 262s returns an empty instance with same comparator 262s 262s Hamster::SortedSet 262s on [] 262s returns self 262s on ["A"] 262s returns self 262s on ["A", "B", "C"] 262s returns self 262s on 1..32 262s returns self 262s on [] 262s returns self 262s on ["A"] 262s returns self 262s on ["A", "B", "C"] 262s returns self 262s on 1..32 262s returns self 262s 262s Hamster::SortedSet 262s #delete_at 262s removes the element at the specified index 262s makes no modification if the index is out of range 262s 262s Hamster::SortedSet 262s #delete 262s on an empty set 262s returns an empty set 262s with an existing value 262s preserves the original 262s returns a copy with the remaining of values 262s with a non-existing value 262s preserves the original values 262s returns self 262s when removing the last value in a sorted set 262s maintains the set order 262s when the set is in natural order 262s returns the canonical empty set 262s on [1, 2, 3], when deleting [1, 2, 3] 262s returns [] 262s on [1, 2, 3, 4], when deleting [1, 2, 3] 262s returns [4] 262s on [1, 2, 3, 4], when deleting [1, 2, 4] 262s returns [3] 262s on [1, 2, 3, 4], when deleting [1, 3, 4] 262s returns [2] 262s on [1, 2, 3, 4], when deleting [2, 3, 4] 262s returns [1] 262s on [1, 2, 3, 4, 5], when deleting [1, 2, 3] 262s returns [4, 5] 262s on [1, 2, 3, 4, 5], when deleting [1, 2, 4] 262s returns [3, 5] 262s on [1, 2, 3, 4, 5], when deleting [1, 2, 5] 262s returns [3, 4] 262s on [1, 2, 3, 4, 5], when deleting [1, 3, 4] 262s returns [2, 5] 262s on [1, 2, 3, 4, 5], when deleting [1, 3, 5] 262s returns [2, 4] 262s on [1, 2, 3, 4, 5], when deleting [1, 4, 5] 262s returns [2, 3] 262s on [1, 2, 3, 4, 5], when deleting [2, 3, 4] 262s returns [1, 5] 262s on [1, 2, 3, 4, 5], when deleting [2, 3, 5] 262s returns [1, 4] 262s on [1, 2, 3, 4, 5], when deleting [2, 4, 5] 262s returns [1, 3] 262s on [1, 2, 3, 4, 5], when deleting [3, 4, 5] 262s returns [1, 2] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 3] 262s returns [4, 5, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 4] 262s returns [3, 5, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 5] 262s returns [3, 4, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 2, 6] 262s returns [3, 4, 5] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 3, 4] 262s returns [2, 5, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 3, 5] 262s returns [2, 4, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 3, 6] 262s returns [2, 4, 5] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 4, 5] 262s returns [2, 3, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 4, 6] 262s returns [2, 3, 5] 262s on [1, 2, 3, 4, 5, 6], when deleting [1, 5, 6] 262s returns [2, 3, 4] 262s on [1, 2, 3, 4, 5, 6], when deleting [2, 3, 4] 262s returns [1, 5, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [2, 3, 5] 262s returns [1, 4, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [2, 3, 6] 262s returns [1, 4, 5] 262s on [1, 2, 3, 4, 5, 6], when deleting [2, 4, 5] 262s returns [1, 3, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [2, 4, 6] 262s returns [1, 3, 5] 262s on [1, 2, 3, 4, 5, 6], when deleting [2, 5, 6] 262s returns [1, 3, 4] 262s on [1, 2, 3, 4, 5, 6], when deleting [3, 4, 5] 262s returns [1, 2, 6] 262s on [1, 2, 3, 4, 5, 6], when deleting [3, 4, 6] 262s returns [1, 2, 5] 262s on [1, 2, 3, 4, 5, 6], when deleting [3, 5, 6] 262s returns [1, 2, 4] 262s on [1, 2, 3, 4, 5, 6], when deleting [4, 5, 6] 262s returns [1, 2, 3] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 3] 262s returns [4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 4] 262s returns [3, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 5] 262s returns [3, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 6] 262s returns [3, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 2, 7] 262s returns [3, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 4] 262s returns [2, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 5] 262s returns [2, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 6] 262s returns [2, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 3, 7] 262s returns [2, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 4, 5] 262s returns [2, 3, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 4, 6] 262s returns [2, 3, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 4, 7] 262s returns [2, 3, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 5, 6] 262s returns [2, 3, 4, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 5, 7] 262s returns [2, 3, 4, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [1, 6, 7] 262s returns [2, 3, 4, 5] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 4] 262s returns [1, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 5] 262s returns [1, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 6] 262s returns [1, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 3, 7] 262s returns [1, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 4, 5] 262s returns [1, 3, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 4, 6] 262s returns [1, 3, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 4, 7] 262s returns [1, 3, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 5, 6] 262s returns [1, 3, 4, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 5, 7] 262s returns [1, 3, 4, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [2, 6, 7] 262s returns [1, 3, 4, 5] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 4, 5] 262s returns [1, 2, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 4, 6] 262s returns [1, 2, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 4, 7] 262s returns [1, 2, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 5, 6] 262s returns [1, 2, 4, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 5, 7] 262s returns [1, 2, 4, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [3, 6, 7] 262s returns [1, 2, 4, 5] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [4, 5, 6] 262s returns [1, 2, 3, 7] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [4, 5, 7] 262s returns [1, 2, 3, 6] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [4, 6, 7] 262s returns [1, 2, 3, 5] 262s on [1, 2, 3, 4, 5, 6, 7], when deleting [5, 6, 7] 262s returns [1, 2, 3, 4] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 3] 262s returns [4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 4] 262s returns [3, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 5] 262s returns [3, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 6] 262s returns [3, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 7] 262s returns [3, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 2, 8] 262s returns [3, 4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 4] 262s returns [2, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 5] 262s returns [2, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 6] 262s returns [2, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 7] 262s returns [2, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 3, 8] 262s returns [2, 4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 5] 262s returns [2, 3, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 6] 262s returns [2, 3, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 7] 262s returns [2, 3, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 4, 8] 262s returns [2, 3, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 5, 6] 262s returns [2, 3, 4, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 5, 7] 262s returns [2, 3, 4, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 5, 8] 262s returns [2, 3, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 6, 7] 262s returns [2, 3, 4, 5, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 6, 8] 262s returns [2, 3, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [1, 7, 8] 262s returns [2, 3, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 4] 262s returns [1, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 5] 262s returns [1, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 6] 262s returns [1, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 7] 262s returns [1, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 3, 8] 262s returns [1, 4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 5] 262s returns [1, 3, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 6] 262s returns [1, 3, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 7] 262s returns [1, 3, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 4, 8] 262s returns [1, 3, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 5, 6] 262s returns [1, 3, 4, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 5, 7] 262s returns [1, 3, 4, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 5, 8] 262s returns [1, 3, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 6, 7] 262s returns [1, 3, 4, 5, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 6, 8] 262s returns [1, 3, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [2, 7, 8] 262s returns [1, 3, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 5] 262s returns [1, 2, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 6] 262s returns [1, 2, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 7] 262s returns [1, 2, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 4, 8] 262s returns [1, 2, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 5, 6] 262s returns [1, 2, 4, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 5, 7] 262s returns [1, 2, 4, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 5, 8] 262s returns [1, 2, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 6, 7] 262s returns [1, 2, 4, 5, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 6, 8] 262s returns [1, 2, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [3, 7, 8] 262s returns [1, 2, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 5, 6] 262s returns [1, 2, 3, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 5, 7] 262s returns [1, 2, 3, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 5, 8] 262s returns [1, 2, 3, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 6, 7] 262s returns [1, 2, 3, 5, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 6, 8] 262s returns [1, 2, 3, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [4, 7, 8] 262s returns [1, 2, 3, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [5, 6, 7] 262s returns [1, 2, 3, 4, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [5, 6, 8] 262s returns [1, 2, 3, 4, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [5, 7, 8] 262s returns [1, 2, 3, 4, 6] 262s on [1, 2, 3, 4, 5, 6, 7, 8], when deleting [6, 7, 8] 262s returns [1, 2, 3, 4, 5] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 3] 262s returns [4, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 4] 262s returns [3, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 5] 262s returns [3, 4, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 6] 262s returns [3, 4, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 7] 262s returns [3, 4, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 8] 262s returns [3, 4, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 2, 9] 262s returns [3, 4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 4] 262s returns [2, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 5] 262s returns [2, 4, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 6] 262s returns [2, 4, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 7] 262s returns [2, 4, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 8] 262s returns [2, 4, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 3, 9] 262s returns [2, 4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 5] 262s returns [2, 3, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 6] 262s returns [2, 3, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 7] 262s returns [2, 3, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 8] 262s returns [2, 3, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 4, 9] 262s returns [2, 3, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 6] 262s returns [2, 3, 4, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 7] 262s returns [2, 3, 4, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 8] 262s returns [2, 3, 4, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 5, 9] 262s returns [2, 3, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 6, 7] 262s returns [2, 3, 4, 5, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 6, 8] 262s returns [2, 3, 4, 5, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 6, 9] 262s returns [2, 3, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 7, 8] 262s returns [2, 3, 4, 5, 6, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 7, 9] 262s returns [2, 3, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [1, 8, 9] 262s returns [2, 3, 4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 4] 262s returns [1, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 5] 262s returns [1, 4, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 6] 262s returns [1, 4, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 7] 262s returns [1, 4, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 8] 262s returns [1, 4, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 3, 9] 262s returns [1, 4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 5] 262s returns [1, 3, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 6] 262s returns [1, 3, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 7] 262s returns [1, 3, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 8] 262s returns [1, 3, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 4, 9] 262s returns [1, 3, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 6] 262s returns [1, 3, 4, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 7] 262s returns [1, 3, 4, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 8] 262s returns [1, 3, 4, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 5, 9] 262s returns [1, 3, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 6, 7] 262s returns [1, 3, 4, 5, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 6, 8] 262s returns [1, 3, 4, 5, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 6, 9] 262s returns [1, 3, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 7, 8] 262s returns [1, 3, 4, 5, 6, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 7, 9] 262s returns [1, 3, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [2, 8, 9] 262s returns [1, 3, 4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 5] 262s returns [1, 2, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 6] 262s returns [1, 2, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 7] 262s returns [1, 2, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 8] 262s returns [1, 2, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 4, 9] 262s returns [1, 2, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 6] 262s returns [1, 2, 4, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 7] 262s returns [1, 2, 4, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 8] 262s returns [1, 2, 4, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 5, 9] 262s returns [1, 2, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 6, 7] 262s returns [1, 2, 4, 5, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 6, 8] 262s returns [1, 2, 4, 5, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 6, 9] 262s returns [1, 2, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 7, 8] 262s returns [1, 2, 4, 5, 6, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 7, 9] 262s returns [1, 2, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [3, 8, 9] 262s returns [1, 2, 4, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 6] 262s returns [1, 2, 3, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 7] 262s returns [1, 2, 3, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 8] 262s returns [1, 2, 3, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 5, 9] 262s returns [1, 2, 3, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 6, 7] 262s returns [1, 2, 3, 5, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 6, 8] 262s returns [1, 2, 3, 5, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 6, 9] 262s returns [1, 2, 3, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 7, 8] 262s returns [1, 2, 3, 5, 6, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 7, 9] 262s returns [1, 2, 3, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [4, 8, 9] 262s returns [1, 2, 3, 5, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 6, 7] 262s returns [1, 2, 3, 4, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 6, 8] 262s returns [1, 2, 3, 4, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 6, 9] 262s returns [1, 2, 3, 4, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 7, 8] 262s returns [1, 2, 3, 4, 6, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 7, 9] 262s returns [1, 2, 3, 4, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [5, 8, 9] 262s returns [1, 2, 3, 4, 6, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [6, 7, 8] 262s returns [1, 2, 3, 4, 5, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [6, 7, 9] 262s returns [1, 2, 3, 4, 5, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [6, 8, 9] 262s returns [1, 2, 3, 4, 5, 7] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9], when deleting [7, 8, 9] 262s returns [1, 2, 3, 4, 5, 6] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 3] 262s returns [4, 5, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 4] 262s returns [3, 5, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 5] 262s returns [3, 4, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 6] 262s returns [3, 4, 5, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 7] 262s returns [3, 4, 5, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 8] 262s returns [3, 4, 5, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 9] 262s returns [3, 4, 5, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 2, 10] 262s returns [3, 4, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 4] 262s returns [2, 5, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 5] 262s returns [2, 4, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 6] 262s returns [2, 4, 5, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 7] 262s returns [2, 4, 5, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 8] 262s returns [2, 4, 5, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 9] 262s returns [2, 4, 5, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 3, 10] 262s returns [2, 4, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 5] 262s returns [2, 3, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 6] 262s returns [2, 3, 5, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 7] 262s returns [2, 3, 5, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 8] 262s returns [2, 3, 5, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 9] 262s returns [2, 3, 5, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 4, 10] 262s returns [2, 3, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 6] 262s returns [2, 3, 4, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 7] 262s returns [2, 3, 4, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 8] 262s returns [2, 3, 4, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 9] 262s returns [2, 3, 4, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 5, 10] 262s returns [2, 3, 4, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 7] 262s returns [2, 3, 4, 5, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 8] 262s returns [2, 3, 4, 5, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 9] 262s returns [2, 3, 4, 5, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 6, 10] 262s returns [2, 3, 4, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 7, 8] 262s returns [2, 3, 4, 5, 6, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 7, 9] 262s returns [2, 3, 4, 5, 6, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 7, 10] 262s returns [2, 3, 4, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 8, 9] 262s returns [2, 3, 4, 5, 6, 7, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 8, 10] 262s returns [2, 3, 4, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [1, 9, 10] 262s returns [2, 3, 4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 4] 262s returns [1, 5, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 5] 262s returns [1, 4, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 6] 262s returns [1, 4, 5, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 7] 262s returns [1, 4, 5, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 8] 262s returns [1, 4, 5, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 9] 262s returns [1, 4, 5, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 3, 10] 262s returns [1, 4, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 5] 262s returns [1, 3, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 6] 262s returns [1, 3, 5, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 7] 262s returns [1, 3, 5, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 8] 262s returns [1, 3, 5, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 9] 262s returns [1, 3, 5, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 4, 10] 262s returns [1, 3, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 6] 262s returns [1, 3, 4, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 7] 262s returns [1, 3, 4, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 8] 262s returns [1, 3, 4, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 9] 262s returns [1, 3, 4, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 5, 10] 262s returns [1, 3, 4, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 7] 262s returns [1, 3, 4, 5, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 8] 262s returns [1, 3, 4, 5, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 9] 262s returns [1, 3, 4, 5, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 6, 10] 262s returns [1, 3, 4, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 7, 8] 262s returns [1, 3, 4, 5, 6, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 7, 9] 262s returns [1, 3, 4, 5, 6, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 7, 10] 262s returns [1, 3, 4, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 8, 9] 262s returns [1, 3, 4, 5, 6, 7, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 8, 10] 262s returns [1, 3, 4, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [2, 9, 10] 262s returns [1, 3, 4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 5] 262s returns [1, 2, 6, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 6] 262s returns [1, 2, 5, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 7] 262s returns [1, 2, 5, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 8] 262s returns [1, 2, 5, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 9] 262s returns [1, 2, 5, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 4, 10] 262s returns [1, 2, 5, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 6] 262s returns [1, 2, 4, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 7] 262s returns [1, 2, 4, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 8] 262s returns [1, 2, 4, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 9] 262s returns [1, 2, 4, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 5, 10] 262s returns [1, 2, 4, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 7] 262s returns [1, 2, 4, 5, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 8] 262s returns [1, 2, 4, 5, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 9] 262s returns [1, 2, 4, 5, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 6, 10] 262s returns [1, 2, 4, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 7, 8] 262s returns [1, 2, 4, 5, 6, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 7, 9] 262s returns [1, 2, 4, 5, 6, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 7, 10] 262s returns [1, 2, 4, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 8, 9] 262s returns [1, 2, 4, 5, 6, 7, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 8, 10] 262s returns [1, 2, 4, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [3, 9, 10] 262s returns [1, 2, 4, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 6] 262s returns [1, 2, 3, 7, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 7] 262s returns [1, 2, 3, 6, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 8] 262s returns [1, 2, 3, 6, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 9] 262s returns [1, 2, 3, 6, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 5, 10] 262s returns [1, 2, 3, 6, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 7] 262s returns [1, 2, 3, 5, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 8] 262s returns [1, 2, 3, 5, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 9] 262s returns [1, 2, 3, 5, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 6, 10] 262s returns [1, 2, 3, 5, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 7, 8] 262s returns [1, 2, 3, 5, 6, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 7, 9] 262s returns [1, 2, 3, 5, 6, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 7, 10] 262s returns [1, 2, 3, 5, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 8, 9] 262s returns [1, 2, 3, 5, 6, 7, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 8, 10] 262s returns [1, 2, 3, 5, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [4, 9, 10] 262s returns [1, 2, 3, 5, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 7] 262s returns [1, 2, 3, 4, 8, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 8] 262s returns [1, 2, 3, 4, 7, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 9] 262s returns [1, 2, 3, 4, 7, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 6, 10] 262s returns [1, 2, 3, 4, 7, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 7, 8] 262s returns [1, 2, 3, 4, 6, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 7, 9] 262s returns [1, 2, 3, 4, 6, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 7, 10] 262s returns [1, 2, 3, 4, 6, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 8, 9] 262s returns [1, 2, 3, 4, 6, 7, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 8, 10] 262s returns [1, 2, 3, 4, 6, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [5, 9, 10] 262s returns [1, 2, 3, 4, 6, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 7, 8] 262s returns [1, 2, 3, 4, 5, 9, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 7, 9] 262s returns [1, 2, 3, 4, 5, 8, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 7, 10] 262s returns [1, 2, 3, 4, 5, 8, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 8, 9] 262s returns [1, 2, 3, 4, 5, 7, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 8, 10] 262s returns [1, 2, 3, 4, 5, 7, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [6, 9, 10] 262s returns [1, 2, 3, 4, 5, 7, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [7, 8, 9] 262s returns [1, 2, 3, 4, 5, 6, 10] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [7, 8, 10] 262s returns [1, 2, 3, 4, 5, 6, 9] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [7, 9, 10] 262s returns [1, 2, 3, 4, 5, 6, 8] 262s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], when deleting [8, 9, 10] 262s returns [1, 2, 3, 4, 5, 6, 7] 262s #delete? 262s with an existing value 262s preserves the original 262s returns a copy with the remaining values 262s with a non-existing value 262s preserves the original values 262s returns false 262s 262s Hamster::SortedSet 262s #difference 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns [] 262s for ["A", "B", "C"] and ["B"] 262s returns ["A", "C"] 262s for ["A", "B", "C"] and ["A", "C"] 262s returns ["B"] 262s for ["A", "B", "C", "D", "E", "F"] and ["B", "E", "F", "G", "M", "X"] 262s returns ["A", "C", "D"] 262s #subtract 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns [] 262s for ["A", "B", "C"] and ["B"] 262s returns ["A", "C"] 262s for ["A", "B", "C"] and ["A", "C"] 262s returns ["B"] 262s for ["A", "B", "C", "D", "E", "F"] and ["B", "E", "F", "G", "M", "X"] 262s returns ["A", "C", "D"] 262s #- 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns [] 262s for ["A", "B", "C"] and ["B"] 262s returns ["A", "C"] 262s for ["A", "B", "C"] and ["A", "C"] 262s returns ["B"] 262s for ["A", "B", "C", "D", "E", "F"] and ["B", "E", "F", "G", "M", "X"] 262s returns ["A", "C", "D"] 262s 262s Hamster::SortedSet 262s #disjoint? 262s for [] and [] 262s returns true 262s for ["A"] and [] 262s returns true 262s for [] and ["A"] 262s returns true 262s for ["A"] and ["A"] 262s returns false 262s for ["A", "B", "C"] and ["B"] 262s returns false 262s for ["B"] and ["A", "B", "C"] 262s returns false 262s for ["A", "B", "C"] and ["D", "E"] 262s returns true 262s for ["F", "G", "H", "I"] and ["A", "B", "C"] 262s returns true 262s for ["A", "B", "C"] and ["A", "B", "C"] 262s returns false 262s for ["A", "B", "C"] and ["A", "B", "C", "D"] 262s returns false 262s for ["D", "E", "F", "G"] and ["A", "B", "C"] 262s returns true 262s 262s Hamster::SortedSet 262s #drop 262s 0 from [] 262s preserves the original 262s returns [] 262s 10 from [] 262s preserves the original 262s returns [] 262s 10 from ["A"] 262s preserves the original 262s returns [] 262s 0 from ["A", "B", "C"] 262s preserves the original 262s returns ["A", "B", "C"] 262s 1 from ["A", "B", "C"] 262s preserves the original 262s returns ["B", "C"] 262s 2 from ["A", "B", "C"] 262s preserves the original 262s returns ["C"] 262s 3 from ["A", "B", "C"] 262s preserves the original 262s returns [] 262s when argument is zero 262s returns self 262s when the set has a custom order 262s maintains the custom order 262s keeps the comparator even when set is cleared 262s when called on a subclass 262s should return an instance of the subclass 262s 262s Hamster::SortedSet 262s #drop_while 262s on [] 262s with a block 262s preserves the original 262s returns [] 262s without a block 262s returns an Enumerator 262s on ["A"] 262s with a block 262s preserves the original 262s returns [] 262s without a block 262s returns an Enumerator 262s on ["A", "B", "C"] 262s with a block 262s preserves the original 262s returns ["C"] 262s without a block 262s returns an Enumerator 262s on ["A", "B", "C", "D", "E", "F", "G"] 262s with a block 262s preserves the original 262s returns ["C", "D", "E", "F", "G"] 262s without a block 262s returns an Enumerator 262s 262s Hamster::SortedSet 262s #each 262s with no block 262s returns an Enumerator 262s with a block 262s returns self 262s iterates over the items in order 262s 262s Hamster::SortedSet 262s #empty? 262s on [] 262s returns true 262s on ["A"] 262s returns false 262s on ["A", "B", "C"] 262s returns false 262s .empty 262s returns the canonical empty set 262s from a subclass 262s returns an empty instance of the subclass 262s 262s Hamster::SortedSet 262s #eql? 262s when comparing to a standard set 262s returns false 262s when comparing to a arbitrary object 262s returns false 262s when comparing to a Hamster::Set 262s returns false 262s when comparing with a subclass of Hamster::SortedSet 262s returns false 262s with an empty set for each comparison 262s returns true 262s with an empty set and a set with nil 262s returns false 262s with a single item array and empty array 262s returns false 262s with matching single item array 262s returns true 262s with mismatching single item array 262s returns false 262s with a multi-item array and single item array 262s returns false 262s with matching multi-item array 262s returns true 262s with a mismatching multi-item array 262s returns true 262s with the same values, but a different sort order 262s returns false 262s 262s Hamster::SortedSet 262s #exclusion 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns [] 262s for ["A", "B", "C"] and ["B"] 262s returns ["A", "C"] 262s for ["A", "B", "C"] and ["B", "C", "D"] 262s returns ["A", "D"] 262s for ["A", "B", "C"] and ["D", "E", "F"] 262s returns ["A", "B", "C", "D", "E", "F"] 262s #^ 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns [] 262s for ["A", "B", "C"] and ["B"] 262s returns ["A", "C"] 262s for ["A", "B", "C"] and ["B", "C", "D"] 262s returns ["A", "D"] 262s for ["A", "B", "C"] and ["D", "E", "F"] 262s returns ["A", "B", "C", "D", "E", "F"] 262s 262s Hamster::SortedSet 262s #fetch 262s gives precedence to default block over default argument if passed both 262s with no default provided 262s when the index exists 262s returns the value at the index 262s when the key does not exist 262s raises an IndexError 262s with a default value 262s when the index exists 262s returns the value at the index 262s when the index does not exist 262s returns the default value 262s with a default block 262s when the index exists 262s returns the value at the index 262s when the index does not exist 262s invokes the block with the missing index as parameter 262s 262s Hamster::SortedSet 262s #find_index 262s looking for "A" in [] without block 262s returns nil 262s looking for "A" in [] with block 262s returns nil 262s looking for nil in [] with block 262s returns nil 262s looking for "A" in ["A"] without block 262s returns 0 262s looking for "A" in ["A"] with block 262s returns 0 262s looking for "B" in ["A"] without block 262s returns nil 262s looking for "B" in ["A"] with block 262s returns nil 262s looking for nil in ["A"] with block 262s returns nil 262s looking for "A" in ["A", "B", "C"] without block 262s returns 0 262s looking for "A" in ["A", "B", "C"] with block 262s returns 0 262s looking for "B" in ["A", "B", "C"] without block 262s returns 1 262s looking for "B" in ["A", "B", "C"] with block 262s returns 1 262s looking for "C" in ["A", "B", "C"] without block 262s returns 2 262s looking for "C" in ["A", "B", "C"] with block 262s returns 2 262s looking for "D" in ["A", "B", "C"] without block 262s returns nil 262s looking for "D" in ["A", "B", "C"] with block 262s returns nil 262s looking for 1 in 0..1 without block 262s returns 1 262s looking for 1 in 0..1 with block 262s returns 1 262s looking for 5 in 0..10 without block 262s returns 5 262s looking for 5 in 0..10 with block 262s returns 5 262s looking for 10 in 0..10 without block 262s returns 10 262s looking for 10 in 0..10 with block 262s returns 10 262s looking for 2 in [2] without block 262s returns 0 262s looking for 2 in [2] with block 262s returns 0 262s looking for 2.0 in [2] without block 262s returns 0 262s looking for 2.0 in [2] with block 262s returns 0 262s looking for 2.0 in [2.0] without block 262s returns 0 262s looking for 2.0 in [2.0] with block 262s returns 0 262s looking for 2 in [2.0] without block 262s returns 0 262s looking for 2 in [2.0] with block 262s returns 0 262s #index 262s looking for "A" in [] without block 262s returns nil 262s looking for "A" in [] with block 262s returns nil 262s looking for nil in [] with block 262s returns nil 262s looking for "A" in ["A"] without block 262s returns 0 262s looking for "A" in ["A"] with block 262s returns 0 262s looking for "B" in ["A"] without block 262s returns nil 262s looking for "B" in ["A"] with block 262s returns nil 262s looking for nil in ["A"] with block 262s returns nil 262s looking for "A" in ["A", "B", "C"] without block 262s returns 0 262s looking for "A" in ["A", "B", "C"] with block 262s returns 0 262s looking for "B" in ["A", "B", "C"] without block 262s returns 1 262s looking for "B" in ["A", "B", "C"] with block 262s returns 1 262s looking for "C" in ["A", "B", "C"] without block 262s returns 2 262s looking for "C" in ["A", "B", "C"] with block 262s returns 2 262s looking for "D" in ["A", "B", "C"] without block 262s returns nil 262s looking for "D" in ["A", "B", "C"] with block 262s returns nil 262s looking for 1 in 0..1 without block 262s returns 1 262s looking for 1 in 0..1 with block 262s returns 1 262s looking for 5 in 0..10 without block 262s returns 5 262s looking for 5 in 0..10 with block 262s returns 5 262s looking for 10 in 0..10 without block 262s returns 10 262s looking for 10 in 0..10 with block 262s returns 10 262s looking for 2 in [2] without block 262s returns 0 262s looking for 2 in [2] with block 262s returns 0 262s looking for 2.0 in [2] without block 262s returns 0 262s looking for 2.0 in [2] with block 262s returns 0 262s looking for 2.0 in [2.0] without block 262s returns 0 262s looking for 2.0 in [2.0] with block 262s returns 0 262s looking for 2 in [2.0] without block 262s returns 0 262s looking for 2 in [2.0] with block 262s returns 0 262s 262s Hamster::SortedSet 262s #first 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["A", "B", "C"] 262s returns "A" 262s on ["Z", "Y", "X"] 262s returns "X" 262s 262s Hamster::SortedSet 262s #from 262s when called without a block 262s returns a sorted set of all items equal to or greater than the argument 262s when called with a block 262s yields all the items equal to or greater than than the argument 262s on an empty set 262s returns an empty set 262s with an argument higher than all the values in the set 262s returns an empty set 262s 262s Hamster::SortedSet 262s #group_by 262s with a block 262s on [] 262s preserves the original 262s returns [] 262s on [1] 262s preserves the original 262s returns [{true=>Hamster::SortedSet[1]}] 262s on [1, 2, 3, 4] 262s preserves the original 262s returns [{true=>Hamster::SortedSet[1, 3], false=>Hamster::SortedSet[2, 4]}] 262s without a block 262s on [] 262s preserves the original 262s returns [] 262s on [1] 262s preserves the original 262s returns [{1=>Hamster::SortedSet[1]}] 262s on [1, 2, 3, 4] 262s preserves the original 262s returns [{1=>Hamster::SortedSet[1], 2=>Hamster::SortedSet[2], 3=>Hamster::SortedSet[3], 4=>Hamster::SortedSet[4]}] 262s from a subclass 262s returns an Hash whose values are instances of the subclass 262s #group 262s with a block 262s on [] 262s preserves the original 262s returns [] 262s on [1] 262s preserves the original 262s returns [{true=>Hamster::SortedSet[1]}] 262s on [1, 2, 3, 4] 262s preserves the original 262s returns [{true=>Hamster::SortedSet[1, 3], false=>Hamster::SortedSet[2, 4]}] 262s without a block 262s on [] 262s preserves the original 262s returns [] 262s on [1] 262s preserves the original 262s returns [{1=>Hamster::SortedSet[1]}] 262s on [1, 2, 3, 4] 262s preserves the original 262s returns [{1=>Hamster::SortedSet[1], 2=>Hamster::SortedSet[2], 3=>Hamster::SortedSet[3], 4=>Hamster::SortedSet[4]}] 262s from a subclass 262s returns an Hash whose values are instances of the subclass 262s #classify 262s with a block 262s on [] 262s preserves the original 262s returns [] 262s on [1] 262s preserves the original 262s returns [{true=>Hamster::SortedSet[1]}] 262s on [1, 2, 3, 4] 262s preserves the original 262s returns [{true=>Hamster::SortedSet[1, 3], false=>Hamster::SortedSet[2, 4]}] 262s without a block 262s on [] 262s preserves the original 262s returns [] 262s on [1] 262s preserves the original 262s returns [{1=>Hamster::SortedSet[1]}] 262s on [1, 2, 3, 4] 262s preserves the original 262s returns [{1=>Hamster::SortedSet[1], 2=>Hamster::SortedSet[2], 3=>Hamster::SortedSet[3], 4=>Hamster::SortedSet[4]}] 262s from a subclass 262s returns an Hash whose values are instances of the subclass 262s 262s Hamster::SortedSet 262s #include? 262s returns true for an existing value (1) 262s returns true for an existing value (2) 262s returns true for an existing value (3) 262s returns true for an existing value (4.0) 262s returns false for a non-existing value 262s uses #<=> for equality 262s #member? 262s returns true for an existing value (1) 262s returns true for an existing value (2) 262s returns true for an existing value (3) 262s returns true for an existing value (4.0) 262s returns false for a non-existing value 262s uses #<=> for equality 262s 262s Hamster::SortedSet 262s #inspect 262s on [] 262s returns "Hamster::SortedSet[]" 262s returns a string which can be eval'd to get an equivalent set 262s on ["A"] 262s returns "Hamster::SortedSet[\"A\"]" 262s returns a string which can be eval'd to get an equivalent set 262s on ["C", "B", "A"] 262s returns "Hamster::SortedSet[\"A\", \"B\", \"C\"]" 262s returns a string which can be eval'd to get an equivalent set 262s from a subclass 262s returns a programmer-readable representation of the set contents 262s returns a string which can be eval'd to get an equivalent set 262s 262s Hamster::SortedSet 262s #intersect? 262s for [] and [] 262s returns false 262s for ["A"] and [] 262s returns false 262s for [] and ["A"] 262s returns false 262s for ["A"] and ["A"] 262s returns true 262s for ["A", "B", "C"] and ["B"] 262s returns true 262s for ["B"] and ["A", "B", "C"] 262s returns true 262s for ["A", "B", "C"] and ["D", "E"] 262s returns false 262s for ["F", "G", "H", "I"] and ["A", "B", "C"] 262s returns false 262s for ["A", "B", "C"] and ["A", "B", "C"] 262s returns true 262s for ["A", "B", "C"] and ["A", "B", "C", "D"] 262s returns true 262s for ["D", "E", "F", "G"] and ["A", "B", "C"] 262s returns false 262s 262s Hamster::SortedSet 262s #intersection 262s for [] and [] 262s returns [] 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns [] 262s for [] and ["A"] 262s returns [] 262s for ["A"] and ["A"] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns ["A"] 262s for ["A", "B", "C"] and ["B"] 262s returns ["B"] 262s for ["B"] and ["A", "B", "C"] 262s returns ["B"] 262s for ["A", "B", "C"] and ["A", "C"] 262s returns ["A", "C"] 262s for ["A", "C"] and ["A", "B", "C"] 262s returns ["A", "C"] 262s for ["A", "M", "T", "X"] and ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] 262s returns ["M", "T"] 262s for ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] and ["A", "M", "T", "X"] 262s returns ["M", "T"] 262s #& 262s for [] and [] 262s returns [] 262s for [] and [] 262s returns [] 262s for ["A"] and [] 262s returns [] 262s for [] and ["A"] 262s returns [] 262s for ["A"] and ["A"] 262s returns ["A"] 262s for ["A"] and ["A"] 262s returns ["A"] 262s for ["A", "B", "C"] and ["B"] 262s returns ["B"] 262s for ["B"] and ["A", "B", "C"] 262s returns ["B"] 262s for ["A", "B", "C"] and ["A", "C"] 262s returns ["A", "C"] 262s for ["A", "C"] and ["A", "B", "C"] 262s returns ["A", "C"] 262s for ["A", "M", "T", "X"] and ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] 262s returns ["M", "T"] 262s for ["B", "C", "D", "E", "F", "G", "H", "I", "M", "P", "Q", "T", "U"] and ["A", "M", "T", "X"] 262s returns ["M", "T"] 262s 262s Hamster::SortedSet 262s #last 262s with an empty set 262s returns the last item 262s with a single item set 262s returns the last item 262s with a multi-item set 262s returns the last item 262s 262s Hamster::SortedSet 262s #map 262s when empty 262s returns self 262s when not empty 262s with a block 262s preserves the original values 262s returns a new set with the mapped values 262s with no block 262s returns an Enumerator 262s on a set ordered by a comparator 262s returns a new set with the mapped values 262s #collect 262s when empty 262s returns self 262s when not empty 262s with a block 262s preserves the original values 262s returns a new set with the mapped values 262s with no block 262s returns an Enumerator 262s on a set ordered by a comparator 262s returns a new set with the mapped values 262s 262s Hamster::SortedSet 262s #marshal_dump/#marshal_load 262s can survive dumping and loading into a new process 262s is still possible to find items by index after loading 262s raises a TypeError if set has a custom sort order 262s 262s Hamster::SortedSet 262s #max 262s with a block 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "Ichi" 262s without a block 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "San" 262s 262s Hamster::SortedSet 262s #min 262s on [] 262s returns nil 262s on ["A"] 262s returns "A" 262s on ["Ichi", "Ni", "San"] 262s returns "Ichi" 262s on [1, 2, 3, 4, 5] 262s returns 1 262s on [0, -0.0, 2.2, -4, -4.2] 262s returns -4.2 262s 262s Hamster::SortedSet 262s .new 262s accepts a single enumerable argument and creates a new sorted set 262s also works with a Range 262s is amenable to overriding of #initialize 262s accepts a block with arity 1 262s accepts a block with arity 2 262s can use a block produced by Symbol#to_proc 262s from a subclass 262s returns a frozen instance of the subclass 262s .[] 262s accepts a variable number of items and creates a new sorted set 262s 262s Hamster::SortedSet 262s #reverse_each 262s with no block 262s returns an Enumerator 262s with a block 262s returns self 262s iterates over the items in order 262s 262s Hamster::SortedSet 262s #sample 262s returns a randomly chosen item 262s 262s Hamster::SortedSet 262s #select 262s when everything matches 262s preserves the original 262s returns self 262s when only some things match 262s with a block 262s preserves the original 262s returns a set with the matching values 262s with no block 262s returns an Enumerator 262s when nothing matches 262s preserves the original 262s returns the canonical empty set 262s from a subclass 262s returns an instance of the same class 262s #find_all 262s when everything matches 262s preserves the original 262s returns self 262s when only some things match 262s with a block 262s preserves the original 262s returns a set with the matching values 262s with no block 262s returns an Enumerator 262s when nothing matches 262s preserves the original 262s returns the canonical empty set 262s from a subclass 262s returns an instance of the same class 262s 262s Hamster::SortedSet 262s #size 262s returns 0 for [] 262s returns 1 for ["A"] 262s returns 3 for ["A", "B", "C"] 262s #length 262s returns 0 for [] 262s returns 1 for ["A"] 262s returns 3 for ["A", "B", "C"] 262s 262s Hamster::SortedSet 262s #slice 262s when passed a positive integral index 262s returns the element at that index 262s leaves the original unchanged 262s when passed a negative integral index 262s returns the element which is number (index.abs) counting from the end of the sorted_set 262s when passed a positive integral index and count 262s returns 'count' elements starting from 'index' 262s leaves the original unchanged 262s when passed a negative integral index and count 262s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 262s when passed a Range 262s returns the elements whose indexes are within the given Range 262s leaves the original unchanged 262s when passed an empty Range 262s does not lose custom sort order 262s when passed a length of zero 262s does not lose custom sort order 262s when passed a subclass of Range 262s works the same as with a Range 262s on a subclass of SortedSet 262s with index and count or a range, returns an instance of the subclass 262s #[] 262s when passed a positive integral index 262s returns the element at that index 262s leaves the original unchanged 262s when passed a negative integral index 262s returns the element which is number (index.abs) counting from the end of the sorted_set 262s when passed a positive integral index and count 262s returns 'count' elements starting from 'index' 262s leaves the original unchanged 262s when passed a negative integral index and count 263s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 263s when passed a Range 263s returns the elements whose indexes are within the given Range 263s leaves the original unchanged 263s when passed an empty Range 263s does not lose custom sort order 263s when passed a length of zero 263s does not lose custom sort order 263s when passed a subclass of Range 263s works the same as with a Range 263s on a subclass of SortedSet 263s with index and count or a range, returns an instance of the subclass 263s 263s Hamster::SortedSet 263s #sort 263s on [] 263s with a block 263s preserves the original 263s returns [] 263s without a block 263s preserves the original 263s returns [] 263s on ["A"] 263s with a block 263s preserves the original 263s returns ["A"] 263s without a block 263s preserves the original 263s returns ["A"] 263s on ["Ichi", "Ni", "San"] 263s with a block 263s preserves the original 263s returns ["Ni", "San", "Ichi"] 263s without a block 263s preserves the original 263s returns ["Ichi", "Ni", "San"] 263s #sort_by 263s on [] 263s with a block 263s preserves the original 263s returns [] 263s without a block 263s preserves the original 263s returns [] 263s on ["A"] 263s with a block 263s preserves the original 263s returns ["A"] 263s without a block 263s preserves the original 263s returns ["A"] 263s on ["Ichi", "Ni", "San"] 263s with a block 263s preserves the original 263s returns ["Ni", "San", "Ichi"] 263s without a block 263s preserves the original 263s returns ["Ichi", "Ni", "San"] 263s 263s Hamster::SortedSet 263s #subset? 263s for [] and [] 263s returns true 263s for ["A"] and [] 263s returns false 263s for [] and ["A"] 263s returns true 263s for ["A"] and ["A"] 263s returns true 263s for ["A", "B", "C"] and ["B"] 263s returns false 263s for ["B"] and ["A", "B", "C"] 263s returns true 263s for ["A", "B", "C"] and ["A", "C"] 263s returns false 263s for ["A", "C"] and ["A", "B", "C"] 263s returns true 263s for ["A", "B", "C"] and ["A", "B", "C"] 263s returns true 263s for ["A", "B", "C"] and ["A", "B", "C", "D"] 263s returns true 263s for ["A", "B", "C", "D"] and ["A", "B", "C"] 263s returns false 263s #proper_subset? 263s for [] and [] 263s returns false 263s for ["A"] and [] 263s returns false 263s for [] and ["A"] 263s returns true 263s for ["A"] and ["A"] 263s returns false 263s for ["A", "B", "C"] and ["B"] 263s returns false 263s for ["B"] and ["A", "B", "C"] 263s returns true 263s for ["A", "B", "C"] and ["A", "C"] 263s returns false 263s for ["A", "C"] and ["A", "B", "C"] 263s returns true 263s for ["A", "B", "C"] and ["A", "B", "C"] 263s returns false 263s for ["A", "B", "C"] and ["A", "B", "C", "D"] 263s returns true 263s for ["A", "B", "C", "D"] and ["A", "B", "C"] 263s returns false 263s 263s Hamster::SortedSet 263s #superset? 263s for [] and [] 263s returns true 263s for ["A"] and [] 263s returns true 263s for [] and ["A"] 263s returns false 263s for ["A"] and ["A"] 263s returns true 263s for ["A", "B", "C"] and ["B"] 263s returns true 263s for ["B"] and ["A", "B", "C"] 263s returns false 263s for ["A", "B", "C"] and ["A", "C"] 263s returns true 263s for ["A", "C"] and ["A", "B", "C"] 263s returns false 263s for ["A", "B", "C"] and ["A", "B", "C"] 263s returns true 263s for ["A", "B", "C"] and ["A", "B", "C", "D"] 263s returns false 263s for ["A", "B", "C", "D"] and ["A", "B", "C"] 263s returns true 263s #proper_superset? 263s for [] and [] 263s returns false 263s for ["A"] and [] 263s returns true 263s for [] and ["A"] 263s returns false 263s for ["A"] and ["A"] 263s returns false 263s for ["A", "B", "C"] and ["B"] 263s returns true 263s for ["B"] and ["A", "B", "C"] 263s returns false 263s for ["A", "B", "C"] and ["A", "C"] 263s returns true 263s for ["A", "C"] and ["A", "B", "C"] 263s returns false 263s for ["A", "B", "C"] and ["A", "B", "C"] 263s returns false 263s for ["A", "B", "C"] and ["A", "B", "C", "D"] 263s returns false 263s for ["A", "B", "C", "D"] and ["A", "B", "C"] 263s returns true 263s 263s Hamster::SortedSet 263s #take 263s 10 from [] 263s preserves the original 263s returns [] 263s 10 from ["A"] 263s preserves the original 263s returns ["A"] 263s 0 from ["A", "B", "C"] 263s preserves the original 263s returns [] 263s 2 from ["A", "B", "C"] 263s preserves the original 263s returns ["A", "B"] 263s when argument is at least size of receiver 263s returns self 263s when the set has a custom order 263s maintains the custom order 263s keeps the comparator even when set is cleared 263s when called on a subclass 263s should return an instance of the subclass 263s 263s Hamster::SortedSet 263s #take_while 263s on [] 263s with a block 263s returns [] 263s preserves the original 263s without a block 263s returns an Enumerator 263s on ["A"] 263s with a block 263s returns ["A"] 263s preserves the original 263s without a block 263s returns an Enumerator 263s on ["A", "B", "C"] 263s with a block 263s returns ["A", "B"] 263s preserves the original 263s without a block 263s returns an Enumerator 263s 263s Hamster::SortedSet 263s #to_set 263s on [] 263s returns a set with the same values 263s on ["A"] 263s returns a set with the same values 263s on ["A", "B", "C"] 263s returns a set with the same values 263s 263s Hamster::SortedSet 263s #union 263s for [] and [] 263s returns [] 263s for [] and [] 263s returns [] 263s for ["A"] and [] 263s returns ["A"] 263s for [] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A", "B", "C"] and [] 263s returns ["A", "B", "C"] 263s for [] and ["A", "B", "C"] 263s returns ["A", "B", "C"] 263s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s #| 263s for [] and [] 263s returns [] 263s for [] and [] 263s returns [] 263s for ["A"] and [] 263s returns ["A"] 263s for [] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A", "B", "C"] and [] 263s returns ["A", "B", "C"] 263s for [] and ["A", "B", "C"] 263s returns ["A", "B", "C"] 263s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s #+ 263s for [] and [] 263s returns [] 263s for [] and [] 263s returns [] 263s for ["A"] and [] 263s returns ["A"] 263s for [] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A", "B", "C"] and [] 263s returns ["A", "B", "C"] 263s for [] and ["A", "B", "C"] 263s returns ["A", "B", "C"] 263s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s #merge 263s for [] and [] 263s returns [] 263s for [] and [] 263s returns [] 263s for ["A"] and [] 263s returns ["A"] 263s for [] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A"] and ["A"] 263s returns ["A"] 263s for ["A", "B", "C"] and [] 263s returns ["A", "B", "C"] 263s for [] and ["A", "B", "C"] 263s returns ["A", "B", "C"] 263s for ["A", "C", "E", "G", "X"] and ["B", "C", "D", "E", "H", "M"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s for ["B", "C", "D", "E", "H", "M"] and ["A", "C", "E", "G", "X"] 263s returns ["A", "B", "C", "D", "E", "G", "H", "M", "X"] 263s 263s Hamster::SortedSet 263s #up_to 263s when called without a block 263s returns a sorted set of all items equal to or less than the argument 263s when called with a block 263s yields all the items equal to or less than than the argument 263s on an empty set 263s returns an empty set 263s with an argument less than all the values in the set 263s returns an empty set 263s 263s Hamster::SortedSet 263s #values_at 263s accepts any number of indices, and returns a sorted_set of items at those indices 263s when passed invalid indices 263s filters them out 263s when passed no arguments 263s returns an empty sorted_set 263s from a subclass 263s returns an instance of the subclass 263s 263s Hamster::Vector 263s #add 263s with a empty vector adding a single item 263s preserves the original 263s adds the item to the vector 263s with a single-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a single-item vector adding a duplicate item 263s preserves the original 263s adds the item to the vector 263s with a 31-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 32-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 33-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1023-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1024-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1025-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s from a subclass 263s returns an instance of the subclass 263s #<< 263s with a empty vector adding a single item 263s preserves the original 263s adds the item to the vector 263s with a single-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a single-item vector adding a duplicate item 263s preserves the original 263s adds the item to the vector 263s with a 31-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 32-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 33-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1023-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1024-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1025-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s from a subclass 263s returns an instance of the subclass 263s #push 263s with a empty vector adding a single item 263s preserves the original 263s adds the item to the vector 263s with a single-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a single-item vector adding a duplicate item 263s preserves the original 263s adds the item to the vector 263s with a 31-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 32-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 33-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1023-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1024-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s with a 1025-item vector adding a different item 263s preserves the original 263s adds the item to the vector 263s from a subclass 263s returns an instance of the subclass 263s 263s Hamster::Vector 263s #any? 263s when created with no values 263s with a block 263s returns false 263s with a block 263s returns false 263s when created with values 263s with a block that returns true 263s returns true 263s with a block that doesn't return true 263s returns false 263s without a block 263s with some values that are truthy 263s returns true 263s with all values that are falsey 263s returns false 263s 263s Hamster::Vector 263s #assoc 263s searches for a 2-element array with a given 1st item 263s returns nil if a matching 1st item is not found 263s uses #== to compare 1st items with provided object 263s skips elements which are not indexable 263s #rassoc 263s searches for a 2-element array with a given 2nd item 263s returns nil if a matching 2nd item is not found 263s uses #== to compare 2nd items with provided object 263s skips elements which are not indexable 263s 263s Hamster::Vector 263s #bsearch 263s with a block which returns false for elements below desired position, and true for those at/above 263s returns the first element for which the predicate is true 263s if the block always returns false 263s returns nil 263s if the block always returns true 263s returns the first element 263s with a block which returns a negative number for elements below desired position, zero for the right element, and positive for those above 263s returns the element for which the block returns zero 263s if the block always returns positive 263s returns nil 263s if the block always returns negative 263s returns nil 263s if the block returns sometimes positive, sometimes negative, but never zero 263s returns nil 263s if not passed a block 263s returns an Enumerator 263s on an empty vector 263s returns nil 263s 263s Hamster::Vector 263s #clear 263s on [] 263s preserves the original 263s returns an empty vector 263s from a subclass 263s returns an instance of the subclass 263s on ["A"] 263s preserves the original 263s returns an empty vector 263s from a subclass 263s returns an instance of the subclass 263s on ["A", "B", "C"] 263s preserves the original 263s returns an empty vector 263s from a subclass 263s returns an instance of the subclass 263s 263s Hamster::Vector 263s #combination 263s works on many combinations of input 263s leaves the original unmodified 263s with a block 263s returns self 263s with no block 263s returns an Enumerator 263s when passed an argument which is out of bounds 263s yields nothing and returns self 263s when passed an argument zero 263s yields an empty array 263s when passed an argument equal to the vector's length 263s yields self as an array 263s when passed an argument 1 263s yields each item in the vector, as single-item vectors 263s when passed another integral argument 263s yields all combinations of the given length 263s on an empty vector 263s works the same 263s 263s Hamster::Vector 263s #compact 263s returns a new Vector with all nils removed 263s doesn't remove false 263s on an empty vector 263s returns self 263s from a subclass 263s returns an instance of the subclass 263s 263s Hamster::Vector 263s #<=> 263s with [] and [1] 263s returns -1 263s with [1] and [] 263s returns 1 263s with [] and [] 263s returns 0 263s with [1] and [2] 263s returns -1 263s with [2] and [1] 263s returns 1 263s with [1] and [1] 263s returns 0 263s with [1] and [1, 2] 263s returns -1 263s with [1, 2] and [1] 263s returns 1 263s with [1] and [1] 263s returns 0 263s with [2, 3, 4] and [3, 4, 5] 263s returns -1 263s with [3, 4, 5] and [2, 3, 4] 263s returns 1 263s with [2, 3, 4] and [2, 3, 4] 263s returns 0 263s with [[0]] and [[1]] 263s returns -1 263s with [[1]] and [[0]] 263s returns 1 263s with [[0]] and [[0]] 263s returns 0 263s 263s Hamster::Vector 263s #+ 263s preserves the original 263s appends the elements in the other enumerable 263s on a 1-item vector 263s works the same 263s on a 31-item vector 263s works the same 263s on a 32-item vector 263s works the same 263s on a 33-item vector 263s works the same 263s on a 1023-item vector 263s works the same 263s on a 1024-item vector 263s works the same 263s on a 1025-item vector 263s works the same 263s #concat 263s preserves the original 263s appends the elements in the other enumerable 263s on a 1-item vector 263s works the same 263s on a 31-item vector 263s works the same 263s on a 32-item vector 263s works the same 263s on a 33-item vector 263s works the same 263s on a 1023-item vector 263s works the same 263s on a 1024-item vector 263s works the same 263s on a 1025-item vector 263s works the same 263s 263s Hamster::Vector 263s on [] 263s returns self 263s on ["A"] 263s returns self 263s on ["A", "B", "C"] 263s returns self 263s on 1..32 263s returns self 263s on [] 263s returns self 263s on ["A"] 263s returns self 263s on ["A", "B", "C"] 263s returns self 263s on 1..32 263s returns self 263s 263s Hamster::Vector 263s #count 263s returns the number of elements 263s returns the number of elements that equal the argument 263s returns the number of element for which the block evaluates to true 263s 263s Hamster::Vector 263s #delete_at 263s removes the element at the specified index 263s makes no modification if the index is out of range 263s works when deleting last item at boundary where vector trie needs to get shallower 263s works on an empty vector 263s works on a vector with 1 item 263s works on a vector with 32 items 263s has the right size and contents after many deletions 263s 263s Hamster::Vector 263s #delete 263s removes elements that are #== to the argument 263s on an empty vector 263s returns self 263s on a subclass of Vector 263s returns an instance of the subclass 263s 263s Hamster::Vector 263s #dig 263s returns value at the index with one argument 263s returns value at index in nested arrays 263s returns nil when indexing deeper than possible 263s returns nil if you index past the end of an array 263s raises a type error when indexing with a key arrays don't understand 263s 263s Hamster::Vector 263s #drop 263s raises an ArgumentError if number of elements specified is negative 263s 10 from [] 263s preserves the original 263s returns [] 263s 10 from ["A"] 263s preserves the original 263s returns [] 263s 1 from ["A"] 263s preserves the original 263s returns [] 263s 0 from ["A"] 263s preserves the original 263s returns ["A"] 263s 0 from ["A", "B", "C"] 263s preserves the original 263s returns ["A", "B", "C"] 263s 2 from ["A", "B", "C"] 263s preserves the original 263s returns ["C"] 263s 3 from 1..32 263s preserves the original 263s returns 4..32 263s 32 from 1..33 263s preserves the original 263s returns [33] 263s when number of elements specified is zero 263s returns self 263s 263s Hamster::Vector 263s #drop_while 263s returns an empty vector if block is always true 263s stops dropping items if block returns nil 263s stops dropping items if block returns false 263s on [] 263s with a block 263s preserves the original 263s returns [] 263s without a block 263s returns an Enumerator 263s on ["A"] 263s with a block 263s preserves the original 263s returns [] 263s without a block 263s returns an Enumerator 263s on ["A", "B", "C"] 263s with a block 263s preserves the original 263s returns ["C"] 263s without a block 263s returns an Enumerator 263s on an empty vector 263s returns an empty vector 263s 263s Hamster::Vector 263s #each_index 263s with a block 263s yields all the valid indices into the vector 263s returns self 263s without a block 263s returns an Enumerator 263s on an empty vector 263s doesn't yield anything 263s on a 1-item vector 263s yields all valid indices 263s on a 2-item vector 263s yields all valid indices 263s on a 10-item vector 263s yields all valid indices 263s on a 31-item vector 263s yields all valid indices 263s on a 32-item vector 263s yields all valid indices 263s on a 33-item vector 263s yields all valid indices 263s on a 1000-item vector 263s yields all valid indices 263s on a 1024-item vector 263s yields all valid indices 263s on a 1025-item vector 263s yields all valid indices 263s 263s Hamster::Vector 263s #each 263s with no block 263s returns an Enumerator 263s on a 31-item vector 263s with a block 263s returns self 263s yields all the items 263s iterates over the items in order 263s on a 32-item vector 263s with a block 263s returns self 263s yields all the items 263s iterates over the items in order 263s on a 33-item vector 263s with a block 263s returns self 263s yields all the items 263s iterates over the items in order 263s on a 1023-item vector 263s with a block 263s returns self 263s yields all the items 263s iterates over the items in order 263s on a 1024-item vector 263s with a block 263s returns self 263s yields all the items 263s iterates over the items in order 263s on a 1025-item vector 263s with a block 263s returns self 263s yields all the items 263s iterates over the items in order 263s on an empty vector 263s doesn't yield anything 263s 263s Hamster::Vector 263s #each_with_index 263s with no block 263s returns an Enumerator 263s on a 1-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 2-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 31-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 32-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 33-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 1023-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 1024-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on a 1025-item vector 263s with a block 263s returns self 263s iterates over the items in order 263s on an empty vector 263s doesn't yield anything 263s 263s Hamster::Vector 263s #empty? 263s on [] 263s returns true 263s on ["A"] 263s returns false 263s on ["A", "B", "C"] 263s returns false 263s .empty 263s returns the canonical empty vector 263s from a subclass 263s returns an empty instance of the subclass 263s calls overridden #initialize when creating empty Hash 263s 263s Hamster::Vector 263s #eql 263s returns false when comparing with an array with the same contents 263s returns false when comparing with an arbitrary object 263s returns false when comparing an empty vector with an empty array 263s returns false when comparing with a subclass of Hamster::Vector 263s #== 263s returns true when comparing with an array with the same contents 263s returns false when comparing with an arbitrary object 263s returns true when comparing an empty vector with an empty array 263s returns true when comparing with a subclass of Hamster::Vector 263s works on larger vectors 263s #eql? 263s returns true 263s for vectors [] and [] 263s for vectors [] and [] 263s returns false 263s for vectors [] and [nil] 263s for vectors [nil] and [] 263s returns false 263s for vectors ["A"] and [] 263s for vectors [] and ["A"] 263s returns true 263s for vectors ["A"] and ["A"] 263s for vectors ["A"] and ["A"] 263s returns false 263s for vectors ["A"] and ["B"] 263s for vectors ["B"] and ["A"] 263s returns false 263s for vectors ["A", "B"] and ["A"] 263s for vectors ["A"] and ["A", "B"] 263s returns true 263s for vectors ["A", "B", "C"] and ["A", "B", "C"] 263s for vectors ["A", "B", "C"] and ["A", "B", "C"] 263s returns false 263s for vectors ["C", "A", "B"] and ["A", "B", "C"] 263s for vectors ["A", "B", "C"] and ["C", "A", "B"] 263s #== 263s returns true 263s for vectors [] and [] 263s for vectors [] and [] 263s returns false 263s for vectors [] and [nil] 263s for vectors [nil] and [] 263s returns false 263s for vectors ["A"] and [] 263s for vectors [] and ["A"] 263s returns true 263s for vectors ["A"] and ["A"] 263s for vectors ["A"] and ["A"] 263s returns false 263s for vectors ["A"] and ["B"] 263s for vectors ["B"] and ["A"] 263s returns false 263s for vectors ["A", "B"] and ["A"] 263s for vectors ["A"] and ["A", "B"] 263s returns true 263s for vectors ["A", "B", "C"] and ["A", "B", "C"] 263s for vectors ["A", "B", "C"] and ["A", "B", "C"] 263s returns false 263s for vectors ["C", "A", "B"] and ["A", "B", "C"] 263s for vectors ["A", "B", "C"] and ["C", "A", "B"] 263s 263s Hamster::Vector 263s #fetch 263s gives precedence to default block over default argument if passed both 263s with no default provided 263s when the index exists 263s returns the value at the index 263s when the key does not exist 263s raises an IndexError 263s with a default value 263s when the index exists 263s returns the value at the index 263s when the index does not exist 263s returns the default value 263s with a default block 263s when the index exists 263s returns the value at the index 263s when the index does not exist 263s invokes the block with the missing index as parameter 263s 263s Hamster::Vector 263s #fill 263s can replace a range of items at the beginning of a vector 263s can replace a range of items in the middle of a vector 263s can replace a range of items at the end of a vector 263s can replace all the items in a vector 263s can fill past the end of the vector 263s behaves like Array#fill, on a variety of inputs 263s with 1 argument 263s replaces all the items in the vector by default 263s with 2 arguments 263s replaces up to the end of the vector by default 263s when index and length are 0 263s leaves the vector unmodified 263s when expanding a vector past boundary where vector trie needs to deepen 263s works the same 263s on a 1000-item vector 263s works the same 263s on a 1023-item vector 263s works the same 263s on a 1024-item vector 263s works the same 263s on a 1025-item vector 263s works the same 263s on a 2000-item vector 263s works the same 263s 263s Hamster::Vector 263s #first 263s on [] 263s returns nil 263s on ["A"] 263s returns "A" 263s on ["A", "B", "C"] 263s returns "A" 263s on 1..32 263s returns 1 263s 263s Hamster::Vector 263s #flat_map 263s with an empty vector 263s returns the flattened values as a Hamster::Vector 263s returns a Hamster::Vector 263s with a block that returns an empty vector 263s returns the flattened values as a Hamster::Vector 263s returns a Hamster::Vector 263s with a vector of one item 263s returns the flattened values as a Hamster::Vector 263s returns a Hamster::Vector 263s with a vector of multiple items 263s returns the flattened values as a Hamster::Vector 263s returns a Hamster::Vector 263s 263s Hamster::Vector 263s #flatten 263s recursively flattens nested vectors into containing vector 263s flattens nested arrays as well 263s leaves the original unmodified 263s with an integral argument 263s only flattens down to the specified depth 263s with an argument of zero 263s returns self 263s on a subclass 263s returns an instance of the subclass 263s on a vector with no nested vectors 263s returns an unchanged vector 263s on a Vector larger than 32 items initialized with Vector.new 263s returns an unchanged vector 263s 263s Hamster::Vector 263s #get 263s when empty 263s always returns nil 263s when not empty 263s with a positive index 263s within the absolute bounds of the vector 263s returns the value at the specified index from the head 263s outside the absolute bounds of the vector 263s returns nil 263s with a negative index 263s within the absolute bounds of the vector 263s returns the value at the specified index from the tail 263s outside the absolute bounds of the vector 263s returns nil 263s on a 1-item vector 263s works correctly, even after various addings and removings 263s on a 10-item vector 263s works correctly, even after various addings and removings 263s on a 31-item vector 263s works correctly, even after various addings and removings 263s on a 32-item vector 263s works correctly, even after various addings and removings 263s on a 33-item vector 263s works correctly, even after various addings and removings 263s on a 1024-item vector 263s works correctly, even after various addings and removings 263s on a 1025-item vector 263s works correctly, even after various addings and removings 263s on a 2000-item vector 263s works correctly, even after various addings and removings 263s #at 263s when empty 263s always returns nil 263s when not empty 263s with a positive index 263s within the absolute bounds of the vector 263s returns the value at the specified index from the head 263s outside the absolute bounds of the vector 263s returns nil 263s with a negative index 263s within the absolute bounds of the vector 263s returns the value at the specified index from the tail 263s outside the absolute bounds of the vector 263s returns nil 263s on a 1-item vector 263s works correctly, even after various addings and removings 263s on a 10-item vector 263s works correctly, even after various addings and removings 263s on a 31-item vector 263s works correctly, even after various addings and removings 263s on a 32-item vector 263s works correctly, even after various addings and removings 263s on a 33-item vector 263s works correctly, even after various addings and removings 263s on a 1024-item vector 263s works correctly, even after various addings and removings 263s on a 1025-item vector 263s works correctly, even after various addings and removings 263s on a 2000-item vector 263s works correctly, even after various addings and removings 263s 263s Hamster::Vector 263s #group_by 263s returns a hash without default proc 263s with a block 263s on [] 263s returns [] 263s on [1] 263s returns [{true=>Hamster::Vector[1]}] 263s on [1, 2, 3, 4] 263s returns [{true=>Hamster::Vector[1, 3], false=>Hamster::Vector[2, 4]}] 263s without a block 263s on [] 263s returns [] 263s on [1] 263s returns [{1=>Hamster::Vector[1]}] 263s on [1, 2, 3, 4] 263s returns [{1=>Hamster::Vector[1], 2=>Hamster::Vector[2], 3=>Hamster::Vector[3], 4=>Hamster::Vector[4]}] 263s on an empty vector 263s returns an empty hash 263s from a subclass 263s returns an Hash whose values are instances of the subclass 263s 263s Hamster::Vector 263s #include? 263s on [] 263s returns false 263s on [] 263s returns false 263s on ["A"] 263s returns true 263s on ["A"] 263s returns false 263s on ["A"] 263s returns false 263s on ["A", "B", nil] 263s returns true 263s on ["A", "B", nil] 263s returns true 263s on ["A", "B", nil] 263s returns true 263s on ["A", "B", nil] 263s returns false 263s on ["A", "B", false] 263s returns true 263s on [2] 263s returns true 263s on [2] 263s returns true 263s on [2.0] 263s returns true 263s on [2.0] 263s returns true 263s #member? 263s on [] 263s returns false 263s on [] 263s returns false 263s on ["A"] 263s returns true 263s on ["A"] 263s returns false 263s on ["A"] 263s returns false 263s on ["A", "B", nil] 263s returns true 263s on ["A", "B", nil] 263s returns true 263s on ["A", "B", nil] 263s returns true 263s on ["A", "B", nil] 263s returns false 263s on ["A", "B", false] 263s returns true 263s on [2] 263s returns true 263s on [2] 263s returns true 263s on [2.0] 263s returns true 263s on [2.0] 263s returns true 263s 263s Hamster::Vector 263s #insert 263s can add items at the beginning of a vector 263s can add items in the middle of a vector 263s can add items at the end of a vector 263s can add items past the end of a vector 263s accepts a negative index, which counts back from the end of the vector 263s raises IndexError if a negative index is too great 263s works when adding an item past boundary when vector trie needs to deepen 263s works when adding to an empty Vector 263s has the right size and contents after many insertions 263s 263s Hamster::Vector 263s #inspect 263s with an empty array 263s returns its contents as a programmer-readable string 263s returns a string which can be eval'd to get back an equivalent vector 263s with a single item array 263s returns its contents as a programmer-readable string 263s returns a string which can be eval'd to get back an equivalent vector 263s with a multi-item array 263s returns its contents as a programmer-readable string 263s returns a string which can be eval'd to get back an equivalent vector 263s from a subclass 263s returns its contents as a programmer-readable string 263s returns a string which can be eval'd to get back an equivalent vector 263s 263s Hamster::Vector 263s #join 263s with a separator 263s on [] 263s preserves the original 263s returns "" 263s on ["A"] 263s preserves the original 263s returns "A" 263s on ["A", "B", "C"] 263s preserves the original 263s returns "A|B|C" 263s without a separator 263s on [] 263s preserves the original 263s returns "" 263s on ["A"] 263s preserves the original 263s returns "A" 263s on ["A", "B", "C"] 263s preserves the original 263s returns "ABC" 263s without a separator (with global default separator set) 263s on ["A", "B", "C"] 263s returns "A**B**C" 263s 263s Hamster::Vector 263s #last 263s with an empty vector 263s returns the last item 263s with a single item vector 263s returns the last item 263s with a multi-item vector 263s returns the last item 263s with a 31-item vector 263s returns the last item 263s with a 32-item vector 263s returns the last item 263s with a 33-item vector 263s returns the last item 263s with a 1023-item vector 263s returns the last item 263s with a 1024-item vector 263s returns the last item 263s with a 1025-item vector 263s returns the last item 263s 263s Hamster::Vector 263s #length 263s with an empty vector 263s returns the values 263s with a single item vector 263s returns the values 263s with a multi-item vector 263s returns the values 263s with a 31-item vector 263s returns the values 263s with a 32-item vector 263s returns the values 263s with a 33-item vector 263s returns the values 263s with a 1023-item vector 263s returns the values 263s with a 1024-item vector 263s returns the values 263s with a 1025-item vector 263s returns the values 263s 263s Hamster::Vector 263s #<< 263s with a empty array adding a single item 263s preserves the original 263s ltlts the item to the vector 263s with a single-item array adding a different item 263s preserves the original 263s ltlts the item to the vector 263s with a single-item array adding a duplicate item 263s preserves the original 263s ltlts the item to the vector 263s with a 31-item vector adding a different item 263s preserves the original 263s ltlts the item to the vector 263s with a 32-item vector adding a different item 263s preserves the original 263s ltlts the item to the vector 263s with a 33-item vector adding a different item 263s preserves the original 263s ltlts the item to the vector 263s with a 1023-item vector adding a different item 263s preserves the original 263s ltlts the item to the vector 263s with a 1024-item vector adding a different item 263s preserves the original 263s ltlts the item to the vector 263s with a 1025-item vector adding a different item 263s preserves the original 263s ltlts the item to the vector 263s from a subclass 263s returns an instance of the subclass 263s 263s Hamster::Vector 263s #map 263s when empty 263s returns self 263s when not empty 263s with a block 263s preserves the original values 263s returns a new vector with the mapped values 263s with no block 263s returns an Enumerator 263s from a subclass 263s returns an instance of the subclass 263s on a large vector 263s works 263s #collect 263s when empty 263s returns self 263s when not empty 263s with a block 263s preserves the original values 263s returns a new vector with the mapped values 263s with no block 263s returns an Enumerator 263s from a subclass 263s returns an instance of the subclass 263s on a large vector 263s works 263s 263s Hamster::Vector 263s #marshal_dump/#marshal_load 263s can survive dumping and loading into a new process 264s is still possible to find items by index after loading 264s 264s Hamster::Vector 264s #max 264s with a block 264s on [] 264s returns nil 264s on ["A"] 264s returns "A" 264s on ["Ichi", "Ni", "San"] 264s returns "Ichi" 264s without a block 264s on [] 264s returns nil 264s on ["A"] 264s returns "A" 264s on ["Ichi", "Ni", "San"] 264s returns "San" 264s 264s Hamster::Vector 264s #min 264s with a block 264s on [] 264s returns nil 264s on ["A"] 264s returns "A" 264s on ["Ichi", "Ni", "San"] 264s returns "Ni" 264s without a block 264s on [] 264s returns nil 264s on ["A"] 264s returns "A" 264s on ["Ichi", "Ni", "San"] 264s returns "Ichi" 264s 264s Hamster::Vector 264s #* 264s raises a TypeError if passed nil 264s raises an ArgumentError if passed no arguments 264s with a String argument 264s acts just like #join 264s with an Integer argument 264s concatenates n copies of the array 264s raises an ArgumentError if integer is negative 264s works on large vectors 264s with a subclass of Vector 264s returns an instance of the subclass 264s 264s Hamster::Vector 264s .new 264s accepts a single enumerable argument and creates a new vector 264s makes a defensive copy of a non-frozen mutable Array passed in 264s is amenable to overriding of #initialize 264s from a subclass 264s returns a frozen instance of the subclass 264s .[] 264s accepts a variable number of items and creates a new vector 264s 264s Hamster::Vector 264s #partition 264s on [] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [1] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [1, 2] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [1, 2, 3] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [1, 2, 3, 4] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [2, 3, 4] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [3, 4] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s on [4] 264s with a block 264s preserves the original 264s returns a frozen array with two items 264s correctly identifies the matches 264s correctly identifies the remainder 264s without a block 264s returns an Enumerator 264s 264s Hamster::Vector 264s #permutation 264s handles duplicate elements correctly 264s leaves the original unmodified 264s behaves like Array#permutation 264s without a block or arguments 264s returns an Enumerator of all permutations 264s without a block, but with integral argument 264s returns an Enumerator of all permutations of given length 264s with a block 264s returns self 264s and no argument 264s yields all permutations 264s and an integral argument 264s yields all permutations of the given length 264s on an empty vector 264s yields the empty permutation 264s with an argument of zero 264s yields the empty permutation 264s with a length greater than the size of the vector 264s yields no permutations 264s 264s Hamster::Vector 264s #pop 264s on [] 264s preserves the original 264s returns [] 264s on ["A"] 264s preserves the original 264s returns [] 264s on ["A", "B", "C"] 264s preserves the original 264s returns ["A", "B"] 264s on 1..32 264s preserves the original 264s returns 1..31 264s on 1..33 264s preserves the original 264s returns 1..32 264s 264s Hamster::Vector 264s #product 264s when passed no arguments 264s multiplies all items in vector 264s when passed one or more vectors 264s when passed a block 264s yields an array for each combination of items from the vectors 264s returns self 264s when not passed a block 264s returns the cartesian product in an array 264s when one of the arguments is empty 264s returns an empty array 264s when the receiver is empty 264s returns an empty array 264s when passed one or more Arrays 264s also calculates the cartesian product correctly 264s 264s Hamster::Vector 264s #put 264s when empty 264s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.1k2Ta7/build.Gja/src/spec/lib/hamster/vector/put_spec.rb:12:in `block (4 levels) in '. 264s raises an error for index -1 264s allows indexes 0 and 1 to be put 264s when not empty 264s with a block 264s and a positive index 264s within the absolute bounds of the vector 264s passes the current value to the block 264s replaces the value with the result of the block 264s supports to_proc methods 264s just past the end of the vector 264s passes nil to the block and adds a new value 264s further outside the bounds of the vector 264s passes nil to the block, fills up missing nils, and adds a new value 264s and a negative index 264s within the absolute bounds of the vector 264s passes the current value to the block 264s replaces the value with the result of the block 264s supports to_proc methods 264s outside the absolute bounds of the vector 264s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.1k2Ta7/build.Gja/src/spec/lib/hamster/vector/put_spec.rb:76:in `block (7 levels) in '. 264s raises an error 264s with a value 264s and a positive index 264s within the absolute bounds of the vector 264s preserves the original 264s puts the new value at the specified index 264s just past the end of the vector 264s adds a new value 264s outside the absolute bounds of the vector 264s fills up with nils 264s with a negative index 264s preserves the original 264s puts the new value at the specified index 264s outside the absolute bounds of the vector 264s WARNING: Using the `raise_error` matcher without providing a specific error or message risks false positives, since `raise_error` will match when Ruby raises a `NoMethodError`, `NameError` or `ArgumentError`, potentially allowing the expectation to pass without even executing the method you are intending to call. Actual error raised was #. Instead consider providing a specific error class or message. This message can be suppressed by setting: `RSpec::Expectations.configuration.on_potential_false_positives = :nothing`. Called from /tmp/autopkgtest.1k2Ta7/build.Gja/src/spec/lib/hamster/vector/put_spec.rb:126:in `block (6 levels) in '. 264s raises an error 264s from a subclass 264s returns an instance of the subclass 264s on a 10-item vector 264s works correctly 264s on a 31-item vector 264s works correctly 264s on a 32-item vector 264s works correctly 264s on a 33-item vector 264s works correctly 264s on a 1000-item vector 264s works correctly 264s on a 1023-item vector 264s works correctly 264s on a 1024-item vector 264s works correctly 264s on a 1025-item vector 264s works correctly 264s on a 2000-item vector 264s works correctly 264s with an identical value to an existing item 264s on a 1-item vector 264s returns self 264s on a 2-item vector 264s returns self 264s on a 5-item vector 264s returns self 264s on a 31-item vector 264s returns self 264s on a 32-item vector 264s returns self 264s on a 33-item vector 264s returns self 264s on a 100-item vector 264s returns self 264s on a 200-item vector 264s returns self 264s 264s Hamster::Vector 264s #reduce 264s on [] 264s with an initial value of 10 264s and a block 264s returns 10 264s on [1] 264s with an initial value of 10 264s and a block 264s returns 9 264s on [1, 2, 3] 264s with an initial value of 10 264s and a block 264s returns 4 264s on [] 264s with no initial value 264s and a block 264s returns nil 264s on [1] 264s with no initial value 264s and a block 264s returns 1 264s on [1, 2, 3] 264s with no initial value 264s and a block 264s returns -4 264s with no block and a symbol argument 264s uses the symbol as the name of a method to reduce with 264s with no block and a string argument 264s uses the string as the name of a method to reduce with 264s #inject 264s on [] 264s with an initial value of 10 264s and a block 264s returns 10 264s on [1] 264s with an initial value of 10 264s and a block 264s returns 9 264s on [1, 2, 3] 264s with an initial value of 10 264s and a block 264s returns 4 264s on [] 264s with no initial value 264s and a block 264s returns nil 264s on [1] 264s with no initial value 264s and a block 264s returns 1 264s on [1, 2, 3] 264s with no initial value 264s and a block 264s returns -4 264s with no block and a symbol argument 264s uses the symbol as the name of a method to reduce with 264s with no block and a string argument 264s uses the string as the name of a method to reduce with 264s 264s Hamster::Vector 264s #reject 264s works with a variety of inputs 264s on [] 264s with a block 264s returns [] 264s without a block 264s returns an Enumerator 264s on ["A"] 264s with a block 264s returns ["A"] 264s without a block 264s returns an Enumerator 264s on ["A", "B", "C"] 264s with a block 264s returns ["A", "B", "C"] 264s without a block 264s returns an Enumerator 264s on ["A", "b", "C"] 264s with a block 264s returns ["A", "C"] 264s without a block 264s returns an Enumerator 264s on ["a", "b", "c"] 264s with a block 264s returns [] 264s without a block 264s returns an Enumerator 264s #delete_if 264s works with a variety of inputs 264s on [] 264s with a block 264s returns [] 264s without a block 264s returns an Enumerator 264s on ["A"] 264s with a block 264s returns ["A"] 264s without a block 264s returns an Enumerator 264s on ["A", "B", "C"] 264s with a block 264s returns ["A", "B", "C"] 264s without a block 264s returns an Enumerator 264s on ["A", "b", "C"] 264s with a block 264s returns ["A", "C"] 264s without a block 264s returns an Enumerator 264s on ["a", "b", "c"] 264s with a block 264s returns [] 264s without a block 264s returns an Enumerator 264s 264s Hamster::Vector 264s #repeated_combination 264s leaves the original unmodified 264s behaves like Array#repeated_combination 264s with no block 264s returns an Enumerator 264s with a block 264s returns self 264s with a negative argument 264s yields nothing and returns self 264s with a zero argument 264s yields an empty array 264s with a argument of 1 264s yields each item in the vector, as single-item vectors 264s on an empty vector, with an argument greater than zero 264s yields nothing 264s with a positive argument, greater than 1 264s yields all combinations of the given size (where a single element can appear more than once in a row) 264s 264s Hamster::Vector 264s #repeated_permutation 264s handles duplicate elements correctly 264s allows permutations larger than the number of elements 264s leaves the original unmodified 264s behaves like Array#repeated_permutation 264s without a block 264s and without argument 264s returns an Enumerator of all repeated permutations 264s with an integral argument 264s returns an Enumerator of all repeated permutations of the given length 264s with a block 264s returns self 264s on an empty vector 264s yields the empty permutation 264s with an argument of zero 264s yields the empty permutation 264s with no argument 264s yields all repeated permutations 264s with a positive integral argument 264s yields all repeated permutations of the given length 264s 264s Hamster::Vector 264s #reverse_each 264s on a 2-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 31-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 32-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 33-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 1000-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 1024-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 1025-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s on a 2000-item vector 264s with a block (internal iteration) 264s returns self 264s yields all items in the opposite order as #each 264s with no block 264s returns an Enumerator 264s 264s Hamster::Vector 264s #reverse 264s on [] 264s returns [] 264s on [1] 264s returns [1] 264s on [1, 2] 264s returns [2, 1] 264s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32] 264s returns [32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 264s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33] 264s returns [33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 264s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100] 264s returns [100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 264s on [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024] 264s returns [1024, 1023, 1022, 1021, 1020, 1019, 1018, 1017, 1016, 1015, 1014, 1013, 1012, 1011, 1010, 1009, 1008, 1007, 1006, 1005, 1004, 1003, 1002, 1001, 1000, 999, 998, 997, 996, 995, 994, 993, 992, 991, 990, 989, 988, 987, 986, 985, 984, 983, 982, 981, 980, 979, 978, 977, 976, 975, 974, 973, 972, 971, 970, 969, 968, 967, 966, 965, 964, 963, 962, 961, 960, 959, 958, 957, 956, 955, 954, 953, 952, 951, 950, 949, 948, 947, 946, 945, 944, 943, 942, 941, 940, 939, 938, 937, 936, 935, 934, 933, 932, 931, 930, 929, 928, 927, 926, 925, 924, 923, 922, 921, 920, 919, 918, 917, 916, 915, 914, 913, 912, 911, 910, 909, 908, 907, 906, 905, 904, 903, 902, 901, 900, 899, 898, 897, 896, 895, 894, 893, 892, 891, 890, 889, 888, 887, 886, 885, 884, 883, 882, 881, 880, 879, 878, 877, 876, 875, 874, 873, 872, 871, 870, 869, 868, 867, 866, 865, 864, 863, 862, 861, 860, 859, 858, 857, 856, 855, 854, 853, 852, 851, 850, 849, 848, 847, 846, 845, 844, 843, 842, 841, 840, 839, 838, 837, 836, 835, 834, 833, 832, 831, 830, 829, 828, 827, 826, 825, 824, 823, 822, 821, 820, 819, 818, 817, 816, 815, 814, 813, 812, 811, 810, 809, 808, 807, 806, 805, 804, 803, 802, 801, 800, 799, 798, 797, 796, 795, 794, 793, 792, 791, 790, 789, 788, 787, 786, 785, 784, 783, 782, 781, 780, 779, 778, 777, 776, 775, 774, 773, 772, 771, 770, 769, 768, 767, 766, 765, 764, 763, 762, 761, 760, 759, 758, 757, 756, 755, 754, 753, 752, 751, 750, 749, 748, 747, 746, 745, 744, 743, 742, 741, 740, 739, 738, 737, 736, 735, 734, 733, 732, 731, 730, 729, 728, 727, 726, 725, 724, 723, 722, 721, 720, 719, 718, 717, 716, 715, 714, 713, 712, 711, 710, 709, 708, 707, 706, 705, 704, 703, 702, 701, 700, 699, 698, 697, 696, 695, 694, 693, 692, 691, 690, 689, 688, 687, 686, 685, 684, 683, 682, 681, 680, 679, 678, 677, 676, 675, 674, 673, 672, 671, 670, 669, 668, 667, 666, 665, 664, 663, 662, 661, 660, 659, 658, 657, 656, 655, 654, 653, 652, 651, 650, 649, 648, 647, 646, 645, 644, 643, 642, 641, 640, 639, 638, 637, 636, 635, 634, 633, 632, 631, 630, 629, 628, 627, 626, 625, 624, 623, 622, 621, 620, 619, 618, 617, 616, 615, 614, 613, 612, 611, 610, 609, 608, 607, 606, 605, 604, 603, 602, 601, 600, 599, 598, 597, 596, 595, 594, 593, 592, 591, 590, 589, 588, 587, 586, 585, 584, 583, 582, 581, 580, 579, 578, 577, 576, 575, 574, 573, 572, 571, 570, 569, 568, 567, 566, 565, 564, 563, 562, 561, 560, 559, 558, 557, 556, 555, 554, 553, 552, 551, 550, 549, 548, 547, 546, 545, 544, 543, 542, 541, 540, 539, 538, 537, 536, 535, 534, 533, 532, 531, 530, 529, 528, 527, 526, 525, 524, 523, 522, 521, 520, 519, 518, 517, 516, 515, 514, 513, 512, 511, 510, 509, 508, 507, 506, 505, 504, 503, 502, 501, 500, 499, 498, 497, 496, 495, 494, 493, 492, 491, 490, 489, 488, 487, 486, 485, 484, 483, 482, 481, 480, 479, 478, 477, 476, 475, 474, 473, 472, 471, 470, 469, 468, 467, 466, 465, 464, 463, 462, 461, 460, 459, 458, 457, 456, 455, 454, 453, 452, 451, 450, 449, 448, 447, 446, 445, 444, 443, 442, 441, 440, 439, 438, 437, 436, 435, 434, 433, 432, 431, 430, 429, 428, 427, 426, 425, 424, 423, 422, 421, 420, 419, 418, 417, 416, 415, 414, 413, 412, 411, 410, 409, 408, 407, 406, 405, 404, 403, 402, 401, 400, 399, 398, 397, 396, 395, 394, 393, 392, 391, 390, 389, 388, 387, 386, 385, 384, 383, 382, 381, 380, 379, 378, 377, 376, 375, 374, 373, 372, 371, 370, 369, 368, 367, 366, 365, 364, 363, 362, 361, 360, 359, 358, 357, 356, 355, 354, 353, 352, 351, 350, 349, 348, 347, 346, 345, 344, 343, 342, 341, 340, 339, 338, 337, 336, 335, 334, 333, 332, 331, 330, 329, 328, 327, 326, 325, 324, 323, 322, 321, 320, 319, 318, 317, 316, 315, 314, 313, 312, 311, 310, 309, 308, 307, 306, 305, 304, 303, 302, 301, 300, 299, 298, 297, 296, 295, 294, 293, 292, 291, 290, 289, 288, 287, 286, 285, 284, 283, 282, 281, 280, 279, 278, 277, 276, 275, 274, 273, 272, 271, 270, 269, 268, 267, 266, 265, 264, 263, 262, 261, 260, 259, 258, 257, 256, 255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224, 223, 222, 221, 220, 219, 218, 217, 216, 215, 214, 213, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, 181, 180, 179, 178, 177, 176, 175, 174, 173, 172, 171, 170, 169, 168, 167, 166, 165, 164, 163, 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, 152, 151, 150, 149, 148, 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 264s 264s Hamster::Vector 264s #rindex 264s when passed an object present in the vector 264s returns the last index where the object is present 264s when passed an object not present in the vector 264s returns nil 264s with a block 264s returns the last index of an object which the predicate is true for 264s without an argument OR block 264s returns an Enumerator 264s 264s Hamster::Vector 264s #rotate 264s leaves the original unmodified 264s when passed no argument 264s returns a new vector with the first element moved to the end 264s with an integral argument n 264s returns a new vector with the first (n % size) elements moved to the end 264s with a floating-point argument n 264s coerces the argument to integer using to_int 264s with a non-numeric argument 264s raises a TypeError 264s with an argument of zero 264s returns self 264s with an argument equal to the vector's size 264s returns self 264s on a 31-item vector 264s behaves like Array#rotate 264s on a 32-item vector 264s behaves like Array#rotate 264s on a 33-item vector 264s behaves like Array#rotate 264s on a 1000-item vector 264s behaves like Array#rotate 264s on a 1023-item vector 264s behaves like Array#rotate 264s on a 1024-item vector 264s behaves like Array#rotate 264s on a 1025-item vector 264s behaves like Array#rotate 264s from a subclass 264s returns an instance of the subclass 264s 264s Hamster::Vector 264s #sample 264s returns a randomly chosen item 264s 264s Hamster::Vector 264s #select 264s works with a variety of inputs 264s with a block 264s preserves the original 264s returns a vector with the matching values 264s with no block 264s returns an Enumerator 264s when nothing matches 264s preserves the original 264s returns an empty vector 264s on an empty vector 264s returns self 264s from a subclass 264s returns an instance of the subclass 264s #find_all 264s works with a variety of inputs 264s with a block 264s preserves the original 264s returns a vector with the matching values 264s with no block 264s returns an Enumerator 264s when nothing matches 264s preserves the original 264s returns an empty vector 264s on an empty vector 264s returns self 264s from a subclass 264s returns an instance of the subclass 264s 264s Hamster::Vector 264s #set 264s without block 264s replaces the element 264s with block 264s passes the existing element to the block and replaces the result 264s 264s Hamster::Vector 264s #shift 264s on [] 264s preserves the original 264s returns [] 264s on ["A"] 264s preserves the original 264s returns [] 264s on ["A", "B", "C"] 264s preserves the original 264s returns ["B", "C"] 264s on 1..31 264s preserves the original 264s returns 2..31 264s on 1..32 264s preserves the original 264s returns 2..32 264s on 1..33 264s preserves the original 264s returns 2..33 264s 264s Hamster::Vector 264s #shuffle 264s returns the same values, in a usually different order 264s leaves the original unchanged 264s from a subclass 264s returns an instance of the subclass 264s on a 32-item vector 264s works correctly 264s on a 33-item vector 264s works correctly 264s on a 1023-item vector 264s works correctly 264s on a 1024-item vector 264s works correctly 264s on a 1025-item vector 264s works correctly 264s 264s Hamster::Vector 264s #slice 264s when passed a positive integral index 265s returns the element at that index 265s leaves the original unchanged 265s when passed a negative integral index 265s returns the element which is number (index.abs) counting from the end of the vector 265s when passed a positive integral index and count 265s returns 'count' elements starting from 'index' 265s leaves the original unchanged 265s when passed a negative integral index and count 265s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 265s when passed a Range 265s returns the elements whose indexes are within the given Range 265s leaves the original unchanged 265s when passed a subclass of Range 265s works the same as with a Range 265s on a subclass of Vector 265s with index and count or a range, returns an instance of the subclass 265s #[] 265s when passed a positive integral index 265s returns the element at that index 265s leaves the original unchanged 265s when passed a negative integral index 265s returns the element which is number (index.abs) counting from the end of the vector 265s when passed a positive integral index and count 265s returns 'count' elements starting from 'index' 265s leaves the original unchanged 265s when passed a negative integral index and count 265s returns 'count' elements, starting from index which is number 'index.abs' counting from the end of the array 265s when passed a Range 265s returns the elements whose indexes are within the given Range 265s leaves the original unchanged 265s when passed a subclass of Range 265s works the same as with a Range 265s on a subclass of Vector 265s with index and count or a range, returns an instance of the subclass 265s 265s Hamster::Vector 265s #sort 265s on [] 265s with a block 265s preserves the original 265s returns [] 265s without a block 265s preserves the original 265s returns [] 265s on ["A"] 265s with a block 265s preserves the original 265s returns ["A"] 265s without a block 265s preserves the original 265s returns ["A"] 265s on ["Ichi", "Ni", "San"] 265s with a block 265s preserves the original 265s returns ["Ni", "San", "Ichi"] 265s without a block 265s preserves the original 265s returns ["Ichi", "Ni", "San"] 265s on a 10-item vector 265s behaves like Arraysort 265s on a 31-item vector 265s behaves like Arraysort 265s on a 32-item vector 265s behaves like Arraysort 265s on a 33-item vector 265s behaves like Arraysort 265s on a 1023-item vector 265s behaves like Arraysort 265s on a 1024-item vector 265s behaves like Arraysort 265s on a 1025-item vector 265s behaves like Arraysort 265s #sort_by 265s on [] 265s with a block 265s preserves the original 265s returns [] 265s without a block 265s preserves the original 265s returns [] 265s on ["A"] 265s with a block 265s preserves the original 265s returns ["A"] 265s without a block 265s preserves the original 265s returns ["A"] 265s on ["Ichi", "Ni", "San"] 265s with a block 265s preserves the original 265s returns ["Ni", "San", "Ichi"] 265s without a block 265s preserves the original 265s returns ["Ichi", "Ni", "San"] 265s on a 10-item vector 265s behaves like Arraysort_by 265s on a 31-item vector 265s behaves like Arraysort_by 265s on a 32-item vector 265s behaves like Arraysort_by 265s on a 33-item vector 265s behaves like Arraysort_by 265s on a 1023-item vector 265s behaves like Arraysort_by 265s on a 1024-item vector 265s behaves like Arraysort_by 265s on a 1025-item vector 265s behaves like Arraysort_by 265s 265s Hamster::Vector 265s #sum 265s on [] 265s returns 0 265s on [2] 265s returns 2 265s on [1, 3, 5, 7, 11] 265s returns 27 265s 265s Hamster::Vector 265s #take 265s 10 from [] 265s preserves the original 265s returns [] 265s 10 from ["A"] 265s preserves the original 265s returns ["A"] 265s 0 from ["A", "B", "C"] 265s preserves the original 265s returns [] 265s 2 from ["A", "B", "C"] 265s preserves the original 265s returns ["A", "B"] 265s 1 from 1..32 265s preserves the original 265s returns [1] 265s 32 from 1..33 265s preserves the original 265s returns 1..32 265s 40 from 1..100 265s preserves the original 265s returns 1..40 265s when number of elements specified is identical to size 265s returns self 265s when number of elements specified is bigger than size 265s returns self 265s 265s Hamster::Vector 265s #take_while 265s on [] 265s with a block 265s returns [] 265s preserves the original 265s without a block 265s returns an Enumerator 265s on ["A"] 265s with a block 265s returns ["A"] 265s preserves the original 265s without a block 265s returns an Enumerator 265s on ["A", "B", "C"] 265s with a block 265s returns ["A", "B"] 265s preserves the original 265s without a block 265s returns an Enumerator 265s 265s Hamster::Vector 265s #to_a 265s with an empty vector 265s returns the values 265s with an single item vector 265s returns the values 265s with an multi-item vector 265s returns the values 265s with a 10-item vector 265s returns the values 265s with a 31-item vector 265s returns the values 265s with a 32-item vector 265s returns the values 265s with a 33-item vector 265s returns the values 265s with a 1000-item vector 265s returns the values 265s with a 1023-item vector 265s returns the values 265s with a 1024-item vector 265s returns the values 265s with a 1025-item vector 265s returns the values 265s 265s Hamster::Vector 265s #to_ary 265s converts using block parameters 265s converts using method arguments 265s converts using splat 265s 265s Hamster::Vector 265s #to_list 265s on [] 265s returns a list 265s the returned list 265s has the correct length 265s contains all values 265s on ["A"] 265s returns a list 265s the returned list 265s has the correct length 265s contains all values 265s on ["A", "B", "C"] 265s returns a list 265s the returned list 265s has the correct length 265s contains all values 265s 265s Hamster::Vector 265s #to_set 265s on [] 265s returns a set with the same values 265s on ["A"] 265s returns a set with the same values 265s on ["A", "B", "C"] 265s returns a set with the same values 265s on 1..10 265s returns a set with the same values 265s on 1..32 265s returns a set with the same values 265s on 1..33 265s returns a set with the same values 265s on 1..1000 265s returns a set with the same values 265s 265s Hamster::Vector 265s #transpose 265s takes a vector of vectors and transposes rows and columns 265s raises an IndexError if the vectors are not of the same length 265s also works on Vectors of Arrays 265s on 10-item vectors 265s behaves like Array#transpose 265s on 31-item vectors 265s behaves like Array#transpose 265s on 32-item vectors 265s behaves like Array#transpose 265s on 33-item vectors 265s behaves like Array#transpose 265s on 1000-item vectors 265s behaves like Array#transpose 265s on 1023-item vectors 265s behaves like Array#transpose 265s on 1024-item vectors 265s behaves like Array#transpose 265s on 1025-item vectors 265s behaves like Array#transpose 265s on 2000-item vectors 265s behaves like Array#transpose 265s on a subclass of Vector 265s returns instances of the subclass 265s 265s Hamster::Vector 265s #uniq 265s returns a vector with no duplicates 265s leaves the original unmodified 265s uses #eql? semantics 265s also uses #hash when determining which values are duplicates 265s keeps the first of each group of duplicate values 265s when passed a block 265s uses the return value of the block to determine which items are duplicate 265s on a vector with no duplicates 265s returns an unchanged vector 265s if the vector has more than 32 elements and is initialized with Vector.new 265s returns an unchanged vector 265s on a 10-item vector 265s behaves like Array#uniq 265s on a 31-item vector 265s behaves like Array#uniq 265s on a 32-item vector 265s behaves like Array#uniq 265s on a 33-item vector 265s behaves like Array#uniq 265s on a 1000-item vector 265s behaves like Array#uniq 265s on a 1023-item vector 265s behaves like Array#uniq 265s on a 1024-item vector 265s behaves like Array#uniq 265s on a 1025-item vector 265s behaves like Array#uniq 265s on a 2000-item vector 265s behaves like Array#uniq 265s from a subclass 265s returns an instance of the subclass 265s 265s Hamster::Vector 265s #unshift 265s on [] with "A" 265s preserves the original 265s returns ["A"] 265s on ["A"] with "B" 265s preserves the original 265s returns ["B", "A"] 265s on ["A"] with "A" 265s preserves the original 265s returns ["A", "A"] 265s on ["A", "B", "C"] with "D" 265s preserves the original 265s returns ["D", "A", "B", "C"] 265s on 1..31 with 0 265s preserves the original 265s returns 0..31 265s on 1..32 with 0 265s preserves the original 265s returns 0..32 265s on 1..33 with 0 265s preserves the original 265s returns 0..33 265s 265s Hamster::Vector 265s #values_at 265s accepts any number of indices, and returns a vector of items at those indices 265s when passed invalid indices 265s fills in with nils 265s when passed no arguments 265s returns an empty vector 265s from a subclass 265s returns an instance of the subclass 265s 265s Hamster::Vector 265s #zip 265s with a block 265s yields arrays of one corresponding element from each input sequence 265s fills in the missing values with nils 265s returns nil 265s can handle multiple inputs, of different classes 265s without a block 265s returns a vector of arrays (one corresponding element from each input sequence) 265s on 10-item vectors 265s behaves like Array#zip 265s on 31-item vectors 265s behaves like Array#zip 265s on 32-item vectors 265s behaves like Array#zip 265s on 33-item vectors 265s behaves like Array#zip 265s on 1000-item vectors 265s behaves like Array#zip 265s on 1023-item vectors 265s behaves like Array#zip 265s on 1024-item vectors 265s behaves like Array#zip 265s on 1025-item vectors 265s behaves like Array#zip 265s from a subclass 265s returns an instance of the subclass 265s 265s Hamster 265s Hash 265s can be loaded separately 265s Set 265s can be loaded separately 265s Vector 265s can be loaded separately 265s List 265s can be loaded separately 265s SortedSet 266s can be loaded separately 266s Deque 266s can be loaded separately 266s 266s Pending: (Failures listed here are expected and do not affect your suite's status) 266s 266s 1) Hamster::List doesn't give horrendously bad performance if thread realizing the list sleeps 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/list/multithreading_spec.rb:33 266s 266s 2) Hamster.to_ruby with Hamster::Hash["e" => Hamster::Hash["g" => 9, "f" => 8], "a" => 1, "b" => Hamster::Vector[2, Hamster::Hash["c" => 3], 4], "d" => Hamster::Set[6, 5, 7], "h" => /ijk/] as input should return {"a"=>1, "b"=>[2, {"c"=>3}, 4], "d"=>#, "e"=>{"f"=>8, "g"=>9}, "h"=>/ijk/} 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 3) Hamster.to_ruby with Hamster::Hash[] as input should return {} 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 4) Hamster.to_ruby with Hamster::Hash["a" => 1, "b" => 2, "c" => 3] as input should return {"a"=>1, "b"=>2, "c"=>3} 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 5) Hamster.to_ruby with Hamster::Vector[] as input should return [] 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 6) Hamster.to_ruby with Hamster::Vector[1, 2, 3] as input should return [1, 2, 3] 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 7) Hamster.to_ruby with Hamster::Set[] as input should return # 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 8) Hamster.to_ruby with Hamster::Set[2, 3, 1] as input should return # 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 9) Hamster.to_ruby with 42 as input should return 42 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s 10) Hamster.to_ruby with #> as input should return #> 266s # Temporarily skipped with xit 266s # ./spec/lib/hamster/nested/construction_spec.rb:64 266s 266s Finished in 15.38 seconds (files took 2.61 seconds to load) 266s 4593 examples, 0 failures, 10 pending 266s 266s mv ./.gem2deb.lib lib 266s autopkgtest [07:09:00]: test gem2deb-test-runner: -----------------------] 270s gem2deb-test-runner PASS 270s autopkgtest [07:09:04]: test gem2deb-test-runner: - - - - - - - - - - results - - - - - - - - - - 274s autopkgtest [07:09:08]: @@@@@@@@@@@@@@@@@@@@ summary 274s gem2deb-test-runner PASS