print ARGF.readpartial(#{@stdin.size})

ARGF.readpartial(1) rescue print $!.class

STR

stdin.should == @stdin + "EOFError"

end

end

@array.bsearch_index { |x| -1 }.should be_nil

end

context "magnitude does not effect the result" do

it "returns the index of any matched elements where element is between 4n <= xn < 8n" do

[1, 2].should include(@array.bsearch_index { |x| (1 - x / 4) * (2**100) })

ruby_version_is '3.1' do

it "recursively matches files and directories in nested dot subdirectory except . with 'nested/**/*' from the current directory and option File::FNM_DOTMATCH" do

expected = %w[

Dir.glob('nested/**/*', File::FNM_DOTMATCH).sort.should == expected.sort

end

RuntimeError.new("new error").detailed_message.should == "new error (RuntimeError)"

end

it "accepts highlight keyword argument and adds escape control sequences" do

RuntimeError.new("new error").detailed_message(highlight: true).should == "\e[1mnew error (\e[1;4mRuntimeError\e[m\e[1m)\e[m"

end

RuntimeError.new("").detailed_message.should == "unhandled exception"

end

DetailedMessageSpec::C.new("").detailed_message.should == "DetailedMessageSpec::C"

end

it "returns a generated class name for an instance of RuntimeError anonymous subclass with empty message" do

klass = Class.new(RuntimeError)

end

end

end

ruby_version_is "3.2" do

it "relies on #detailed_message" do

e = RuntimeError.new("new error")

e.full_message.lines.first.should =~ /DETAILED MESSAGE/

end

e = RuntimeError.new("new error")

"DETAILED MESSAGE"

end

e.full_message(foo: "bar")

end

end

end

it "returns false if trying to lock an exclusively locked file" do

@file.flock File::LOCK_EX

File.open('#{@name}', "w") do |f2|

print f2.flock(File::LOCK_EX | File::LOCK_NB).to_s

end

it "blocks if trying to lock an exclusively locked file" do

@file.flock File::LOCK_EX

running = false

t = Thread.new do

}.should raise_error(Errno::EEXIST, /File exists/)

end

it "raises a TypeError if the first parameter can't be coerced to a string" do

-> { File.new(true) }.should raise_error(TypeError)

-> { File.new(false) }.should raise_error(TypeError)

it "matches ranges of characters using exclusive bracket expression (e.g. [^t] or [!t])" do

File.send(@method, 'ca[^t]', 'cat').should == false

File.send(@method, 'ca[!t]', 'cat').should == false

end

end

end

it "does not match '/' characters with ? or * when flags includes FNM_PATHNAME" do

File.send(@method, '?', '/', File::FNM_PATHNAME).should == false

File.send(@method, '*', '/', File::FNM_PATHNAME).should == false

File.should_not.send(@method, '*/*', 'dave/.profile', File::FNM_PATHNAME)

end

File.send(@method, '.*', '.profile').should == true

File.send(@method, ".*file", "nondotfile").should == false

end

it "matches leading periods in filenames when flags includes FNM_DOTMATCH" do

File.send(@method, pattern, 'a/.b/c/foo', File::FNM_PATHNAME | File::FNM_DOTMATCH).should be_true

end

it "accepts an object that has a #to_path method" do

File.send(@method, '\*', mock_to_path('a')).should == false

end

end

it "raises an IOError if the destination IO is not open for writing" do

end

it "does not close the destination IO" do

end

after :each do

end

describe "from an IO" do

it_behaves_like :io_copy_stream_to_io, nil, IOSpecs::CopyStream

it_behaves_like :io_copy_stream_to_io_with_offset, nil, IOSpecs::CopyStream

end

end

describe "from a file name" do

@io.should_not_receive(:pos)

IO.copy_stream(@io, @to_name)

end

end

describe "with a destination that does partial reads" do

before do

@from_out, @from_in = IO.pipe

end

end

it "returns nil if called at the end of the stream" do

IOSpecs.lines.length.times { @io.gets }

@io.gets.should == nil

describe "IO.new" do

it_behaves_like :io_new, :new

end

describe "IO.new" do

ScratchPad.recorded.should == :called

end

it "propagates an exception raised by #close that is not a StandardError" do

-> do

IO.open(@fd, "w") do |io|

buffer.should == "567"

end

it "does not advance the file pointer" do

@file.pread(4, 0).should == "1234"

@file.read.should == "1234567890"

end

it "raises EOFError if end-of-file is reached" do

-> { @file.pread(1, 10) }.should raise_error(EOFError)

end

@file.pread(6, 0).should == "foobar"

end

it "raises IOError when file is not open in write mode" do

File.open(@fname, "r") do |file|

end

end

it "raises IOError when file is closed" do

file = File.open(@fname, "w+")

file.close

end

end

end

IO.read(@fname, 1, 10).should == nil

end

it "raises an Errno::ENOENT when the requested file does not exist" do

rm_r @fname

-> { IO.read @fname }.should raise_error(Errno::ENOENT)

@io.read(4).should == '7890'

end

it "clears the output buffer if there is nothing to read" do

@io.pos = 10

it "returns a String in BINARY when passed a size" do

@io.read(4).encoding.should equal(Encoding::BINARY)

end

it "does not change the buffer's encoding when passed a limit" do

$_.should == "test"

end

it "raises an IOError when self is not readable" do

-> { IOSpecs.closed_io.send(@method) {} }.should raise_error(IOError)

end

end

it "runs the specified command, replacing current process" do

end

end

describe "Kernel.exec" do

it "runs the specified command, replacing current process" do

end

end

object.should_receive(:write).with("string")

Kernel.printf(object, "%s", "string")

end

end

describe "Kernel.printf" do

main = self

describe :kernel_load, shared: true do

before :each do

CodeLoadingSpecs.spec_setup

CodeLoadingSpecs.spec_cleanup

end

end

end

describe :kernel_require, shared: true do

describe "(path resolution)" do

# For reference see [ruby-core:24155] in which matz confirms this feature is

# intentional for security reasons.

it "does not load a bare filename unless the current working directory is in $LOAD_PATH" do

require_relative '../../spec_helper'

describe "Kernel#sleep" do

it "is a private method" do

require_relative 'shared/sprintf'

require_relative 'shared/sprintf_encoding'

describe "Kernel#sprintf" do

it_behaves_like :kernel_sprintf, -> format, *args {

sprintf(format, *args)

it_behaves_like :kernel_sprintf_encoding, -> format, *args {

sprintf(format, *args)

}

end

describe "Kernel.sprintf" do

it_behaves_like :kernel_sprintf_encoding, -> format, *args {

Kernel.sprintf(format, *args)

}

end

require_relative '../../spec_helper'

# Should be synchronized with core/array/values_at_spec.rb and core/struct/values_at_spec.rb

#

# /(.)(.)(\d+)(\d)/.match("THX1138: The Movie").to_a # => ["HX1138", "H", "X", "113", "8"]

end

it "supports beginningless Range" do

end

it "returns an empty Array when Range is empty" do

end

end

end

end

end

end

end

before :each do

@klass = Class.new do

def m(a, b, *c)

end

end

before :each do

@klass = Class.new do

def m(a, b, *c)

end

end

describe "and a method is defined inside" do

it "defines the nested method in the default definee where the Proc was created" do

prc = nil

end

end

describe "behaves exactly like a lambda" do

it "for return" do

Class.new do

end

platform_is :netbsd, :freebsd do

Process::RLIMIT_SBSIZE.should == 9 # FIXME: what's it equal?

Process::RLIMIT_AS.should == 10

end

end

platform_is :windows do

it "does not define RLIMIT constants" do

%i[

end

it "runs the specified command, replacing current process" do

end

it "sets the current directory when given the :chdir option" do

tmpdir = tmp("")[0..-2]

platform_is_not :windows do

end

platform_is :windows do

end

end

platform_is_not :windows do

it "subjects the specified command to shell expansion" do

result = Dir.chdir(@dir) do

end

result.chomp.should == @name

end

it "creates an argument array with shell parsing semantics for whitespace" do

end

end

# There is no shell expansion on Windows

it "does not subject the specified command to shell expansion on Windows" do

result = Dir.chdir(@dir) do

end

result.should == "*\n"

end

it "does not create an argument array with shell parsing semantics for whitespace on Windows" do

end

end

platform_is :windows do

cmd = '"cmd.exe", "/C", "echo", "*"'

end

end

end

end

it "sets environment variables in the child environment" do

end

it "unsets environment variables whose value is nil" do

platform_is_not :windows do

end

platform_is :windows do

# On Windows, echo-ing a non-existent env var is treated as echo-ing any other string of text

end

end

it "coerces environment argument using to_hash" do

end

it "unsets other environment variables when given a true :unsetenv_others option" do

platform_is_not :windows do

end

platform_is :windows do

end

end

end

describe "with a command array" do

it "uses the first element as the command name and the second as the argv[0] value" do

platform_is_not :windows do

end

platform_is :windows do

end

end

it "coerces the argument using to_ary" do

platform_is_not :windows do

end

platform_is :windows do

end

end

end

EOC

child_fd = IO.read(@child_fd_file).to_i

child_fd.to_i.should > STDERR.fileno

Process.exec("#{ruby_cmd(map_fd_fixture)} \#{f.fileno}", f.fileno => f.fileno)

EOC

child_fd, close_on_exec = output.split

child_fd.to_i.should > STDERR.fileno

puts(f.close_on_exec?)

EOC

output.split.should == ['true', 'false']

end

end

Regexp.union("\u00A9".encode("ISO-8859-1"), "a".encode("UTF-8")).encoding.should == Encoding::ISO_8859_1

end

it "returns a Regexp with UTF-8 if one part is UTF-8" do

Regexp.union(/probl[éeè]me/i, /help/i).encoding.should == Encoding::UTF_8

end

it "raises ArgumentError if the arguments include conflicting ASCII-incompatible Strings" do

-> {

Regexp.union("a".encode("UTF-16LE"), "b".encode("UTF-16BE"))

end

it "raises ArgumentError if the arguments include conflicting ASCII-incompatible Regexps" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-16LE")),

Regexp.new("b".encode("UTF-16BE")))

end

it "raises ArgumentError if the arguments include conflicting fixed encoding Regexps" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-8"), Regexp::FIXEDENCODING),

Regexp.new("b".encode("US-ASCII"), Regexp::FIXEDENCODING))

end

it "raises ArgumentError if the arguments include a fixed encoding Regexp and a String containing non-ASCII-compatible characters in a different encoding" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-8"), Regexp::FIXEDENCODING),

"\u00A9".encode("ISO-8859-1"))

end

it "raises ArgumentError if the arguments include a String containing non-ASCII-compatible characters and a fixed encoding Regexp in a different encoding" do

-> {

Regexp.union("\u00A9".encode("ISO-8859-1"),

Regexp.new("a".encode("UTF-8"), Regexp::FIXEDENCODING))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible String and an ASCII-only String" do

-> {

Regexp.union("a".encode("UTF-16LE"), "b".encode("UTF-8"))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible Regexp and an ASCII-only String" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-16LE")), "b".encode("UTF-8"))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible String and an ASCII-only Regexp" do

-> {

Regexp.union("a".encode("UTF-16LE"), Regexp.new("b".encode("UTF-8")))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible Regexp and an ASCII-only Regexp" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-16LE")), Regexp.new("b".encode("UTF-8")))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible String and a String containing non-ASCII-compatible characters in a different encoding" do

-> {

Regexp.union("a".encode("UTF-16LE"), "\u00A9".encode("ISO-8859-1"))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible Regexp and a String containing non-ASCII-compatible characters in a different encoding" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-16LE")), "\u00A9".encode("ISO-8859-1"))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible String and a Regexp containing non-ASCII-compatible characters in a different encoding" do

-> {

Regexp.union("a".encode("UTF-16LE"), Regexp.new("\u00A9".encode("ISO-8859-1")))

end

it "raises ArgumentError if the arguments include an ASCII-incompatible Regexp and a Regexp containing non-ASCII-compatible characters in a different encoding" do

-> {

Regexp.union(Regexp.new("a".encode("UTF-16LE")), Regexp.new("\u00A9".encode("ISO-8859-1")))

end

it "uses to_str to convert arguments (if not Regexp)" do

not_supported_on :opal do

Regexp.union([/dogs/, /cats/i]).should == /(?-mix:dogs)|(?i-mx:cats)/

end

end

end

Signal.signame(-1).should == nil

end

it "raises a TypeError when the passed argument can't be coerced to Integer" do

-> { Signal.signame("hello") }.should raise_error(TypeError)

end

platform_is_not :windows do

it "the original should take precedence over alias when looked up by number" do

Signal.signame(Signal.list["ABRT"]).should == "ABRT"

Signal.trap(:HUP, @saved_trap).should equal(@proc)

end

it "raises ArgumentError when passed unknown signal" do

-> { Signal.trap(300) { } }.should raise_error(ArgumentError, "invalid signal number (300)")

-> { Signal.trap("USR10") { } }.should raise_error(ArgumentError, "unsupported signal `SIGUSR10'")

"\xA9".should.start_with?("\xA9") # A9 is not a character head for UTF-8

end

it "checks we are matching only part of a character" do

"\xe3\x81\x82".size.should == 1

"\xe3\x81\x82".should_not.start_with?("\xe3")

output.should_not.frozen?

output.should == 'foo'

end

it 'returns self if the String is not frozen' do

end

end

end

end

end

require_relative '../../spec_helper'

describe "Warning.[]" do

end

ruby_version_is '3.3' do