8000 [YARP] Restructure tests to compare YARP evaluation to CRuby evaluation by jemmaissroff · Pull Request #8467 · ruby/ruby · GitHub
[go: up one dir, main page]
Skip to content

[YARP] Restructure tests to compare YARP evaluation to CRuby evaluation #8467

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Sep 18, 2023
Merged

[YARP] Restructure tests to compare YARP evaluation to CRuby evaluation #8467

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
[YARP] Restructure tests to compare YARP evaluation to CRuby evaluation 
Previously, we were hardcoding the expected evaluation value. Now,
instead, we structure it so that we compare the YARP evaluation value
against CRuby's evaluation value.
  • Loading branch information
@jemmaissroff
jemmaissroff committed Sep 18, 2023
commit b6f8de033d21ba744f815fe42b74dd21cd35cbb2
153 changes: 80 additions & 73 deletions test/yarp/compiler_test.rb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,215 +3,219 @@
module YARP
class CompilerTest < Test::Unit::TestCase
def test_empty_program
assert_nil compile("")
test_yarp_eval("")
end

############################################################################
# Literals #
############################################################################

def test_FalseNode
assert_equal false, compile("false")
test_yarp_eval("false")
end

def test_FloatNode
assert_equal 1.2, compile("1.2")
assert_equal 1.2e3, compile("1.2e3")
assert_equal(+1.2e+3, compile("+1.2e+3"))
assert_equal(-1.2e-3, compile("-1.2e-3"))
test_yarp_eval("1.2")
test_yarp_eval("1.2e3")
test_yarp_eval("+1.2e+3")
test_yarp_eval("-1.2e-3")
end

def test_ImaginaryNode
assert_equal 1i, compile("1i")
assert_equal +1.0i, compile("+1.0i")
assert_equal 1ri, compile("1ri")
test_yarp_eval("1i")
test_yarp_eval("+1.0i")
test_yarp_eval("1ri")
end

def test_IntegerNode
assert_equal 1, compile("1")
assert_equal(+1, compile("+1"))
assert_equal(-1, compile("-1"))
assert_equal 0x10, compile("0x10")
assert_equal 0b10, compile("0b10")
assert_equal 0o10, compile("0o10")
assert_equal 010, compile("010")
test_yarp_eval("1")
test_yarp_eval("+1")
test_yarp_eval("-1")
test_yarp_eval("0x10")
test_yarp_eval("0b10")
test_yarp_eval("0o10")
test_yarp_eval("010")
end

def test_NilNode
assert_nil compile("nil")
test_yarp_eval("nil")
end

def test_RationalNode
assert_equal 1.2r, compile("1.2r")
assert_equal +1.2r, compile("+1.2r")
test_yarp_eval("1.2r")
test_yarp_eval("+1.2r")
end

def test_SelfNode
assert_equal TOPLEVEL_BINDING.eval("self"), compile("self")
test_yarp_eval("self")
end

def test_TrueNode
assert_equal true, compile("true")
test_yarp_eval("true")
end

############################################################################
# Reads #
############################################################################

def test_ClassVariableReadNode
assert_equal 1, compile("class YARP::CompilerTest; @@yct = 1; @@yct; end")
test_yarp_eval("class YARP::CompilerTest; @@yct = 1; @@yct; end")
end

def test_ConstantPathNode
assert_equal YARP::CompilerTest, compile("YARP::CompilerTest")
test_yarp_eval("YARP::CompilerTest")
end

def test_ConstantReadNode
assert_equal YARP, compile("YARP")
test_yarp_eval("YARP")
end

def test_GlobalVariableReadNode
assert_equal 1, compile("$yct = 1; $yct")
test_yarp_eval("$yct = 1; $yct")
end

def test_InstanceVariableReadNode
assert_equal 1, compile("class YARP::CompilerTest; @yct = 1; @yct; end")
test_yarp_eval("class YARP::CompilerTest; @yct = 1; @yct; end")
end

def test_LocalVariableReadNode
assert_equal 1, compile("yct = 1; yct")
test_yarp_eval("yct = 1; yct")
end

############################################################################
# Writes #
############################################################################

def test_ClassVariableWriteNode
assert_equal 1, compile("class YARP::CompilerTest; @@yct = 1; end")
test_yarp_eval("class YARP::CompilerTest; @@yct = 1; end")
end

def test_ClassVariableAndWriteNode
assert_equal 1, compile("class YARP::CompilerTest; @@yct = 0; @@yct &&= 1; end")
test_yarp_eval("class YARP::CompilerTest; @@yct = 0; @@yct &&= 1; end")
end

def test_ClassVariableOrWriteNode
assert_equal 1, compile("class YARP::CompilerTest; @@yct = 1; @@yct ||= 0; end")
assert_equal 1, compile("class YARP::CompilerTest; @@yct = nil; @@yct ||= 1; end")
test_yarp_eval("class YARP::CompilerTest; @@yct = 1; @@yct ||= 0; end")
test_yarp_eval("class YARP::CompilerTest; @@yct = nil; @@yct ||= 1; end")
end

def test_ClassVariableOperatorWriteNode
assert_equal 1, compile("class YARP::CompilerTest; @@yct = 0; @@yct += 1; end")
test_yarp_eval("class YARP::CompilerTest; @@yct = 0; @@yct += 1; end")
end

def test_ConstantWriteNode
# We don't call test_yarp_eval directly in this case becuase we
# don't want to assign the constant mutliple times if we run
# with `--repeat-count`
# Instead, we eval manually here, and remove the constant to
constant_name = "YCT"
assert_equal 1, compile("#{constant_name} = 1")
# We remove the constant to avoid assigning it mutliple
# times if we run with `--repeat_count`
source = "#{constant_name} = 1"
yarp_eval = RubyVM::InstructionSequence.compile_yarp(source).eval
assert_equal yarp_eval, 1
Object.send(:remove_const, constant_name)
end

def test_ConstantPathWriteNode
# assert_equal 1, compile("YARP::YCT = 1")
# test_yarp_eval("YARP::YCT = 1")
end

def test_GlobalVariableWriteNode
assert_equal 1, compile("$yct = 1")
test_yarp_eval("$yct = 1")
end

def test_GlobalVariableAndWriteNode
assert_equal 1, compile("$yct = 0; $yct &&= 1")
test_yarp_eval("$yct = 0; $yct &&= 1")
end

def test_GlobalVariableOrWriteNode
assert_equal 1, compile("$yct ||= 1")
test_yarp_eval("$yct ||= 1")
end

def test_GlobalVariableOperatorWriteNode
assert_equal 1, compile("$yct = 0; $yct += 1")
test_yarp_eval("$yct = 0; $yct += 1")
end

def test_InstanceVariableWriteNode
assert_equal 1, compile("class YARP::CompilerTest; @yct = 1; end")
test_yarp_eval("class YARP::CompilerTest; @yct = 1; end")
end

def test_InstanceVariableAndWriteNode
assert_equal 1, compile("@yct = 0; @yct &&= 1")
test_yarp_eval("@yct = 0; @yct &&= 1")
end

def test_InstanceVariableOrWriteNode
assert_equal 1, compile("@yct ||= 1")
test_yarp_eval("@yct ||= 1")
end

def test_InstanceVariableOperatorWriteNode
assert_equal 1, compile("@yct = 0; @yct += 1")
test_yarp_eval("@yct = 0; @yct += 1")
end

def test_LocalVariableWriteNode
assert_equal 1, compile("yct = 1")
test_yarp_eval("yct = 1")
end

def test_LocalVariableAndWriteNode
assert_equal 1, compile("yct = 0; yct &&= 1")
test_yarp_eval("yct = 0; yct &&= 1")
end

def test_LocalVariableOrWriteNode
assert_equal 1, compile("yct ||= 1")
test_yarp_eval("yct ||= 1")
end

def test_LocalVariableOperatorWriteNode
assert_equal 1, compile("yct = 0; yct += 1")
test_yarp_eval("yct = 0; yct += 1")
end

############################################################################
# String-likes #
############################################################################

def test_EmbeddedVariableNode
# assert_equal "1", compile('class YARP::CompilerTest; @yct = 1; "#@yct"; end')
# assert_equal "1", compile('class YARP::CompilerTest; @@yct = 1; "#@@yct"; end')
assert_equal "1", compile('$yct = 1; "#$yct"')
# test_yarp_eval('class YARP::CompilerTest; @yct = 1; "#@yct"; end')
# test_yarp_eval('class YARP::CompilerTest; @@yct = 1; "#@@yct"; end')
test_yarp_eval('$yct = 1; "#$yct"')
end

def test_InterpolatedRegularExpressionNode
assert_equal /1 1 1/, compile('$yct = 1; /1 #$yct 1/')
assert_equal /1 3 1/, compile('/1 #{1 + 2} 1/')
assert_equal /1 2 3 1/, compile('/1 #{"2"} #{1 + 2} 1/')
test_yarp_eval('$yct = 1; /1 #$yct 1/')
test_yarp_eval('/1 #{1 + 2} 1/')
test_yarp_eval('/1 #{"2"} #{1 + 2} 1/')
end

def test_InterpolatedStringNode
assert_equal "1 1 1", compile('$yct = 1; "1 #$yct 1"')
assert_equal "1 3 1", compile('"1 #{1 + 2} 1"')
test_yarp_eval('$yct = 1; "1 #$yct 1"')
test_yarp_eval('"1 #{1 + 2} 1"')
end

def test_InterpolatedSymbolNode
assert_equal :"1 1 1", compile('$yct = 1; :"1 #$yct 1"')
assert_equal :"1 3 1", compile(':"1 #{1 + 2} 1"')
test_yarp_eval('$yct = 1; :"1 #$yct 1"')
test_yarp_eval(':"1 #{1 + 2} 1"')
end

def test_InterpolatedXStringNode
assert_equal "1\n", compile('`echo #{1}`')
assert_equal "100", compile('`printf "100"`')
test_yarp_eval('`echo #{1}`')
test_yarp_eval('`printf "100"`')
end

def test_RegularExpressionNode
assert_equal /yct/, compile('/yct/')
test_yarp_eval('/yct/')
end

def test_StringConcatNode
# assert_equal "YARP::CompilerTest", compile('"YARP" "::" "CompilerTest"')
# test_yarp_eval('"YARP" "::" "CompilerTest"')
end

def test_StringNode
assert_equal "yct", compile('"yct"')
test_yarp_eval('"yct"')
end

def test_SymbolNode
assert_equal :yct, compile(":yct")
test_yarp_eval(":yct")
end

def test_XStringNode
# assert_equal "yctyct", compile(<<~RUBY)
# test_yarp_eval(<<~RUBY)
# class YARP::CompilerTest
# def self.`(command) = command * 2
# `yct`
Expand All @@ -224,28 +228,31 @@ def test_XStringNode
############################################################################

def test_AndNode
assert_equal 1, compile("true && 1")
assert_equal false, compile("false && 1")
test_yarp_eval("true && 1")
test_yarp_eval("false && 1")
end

def test_OrNode
assert_equal true, compile("true || 1")
assert_equal 1, compile("false || 1")
test_yarp_eval("true || 1")
test_yarp_eval("false || 1")
end

############################################################################
# Scopes/statements #
############################################################################

def test_ParenthesesNode
assert_equal (), compile("()")
assert_equal (1), compile("(1)")
test_yarp_eval("()")
test_yarp_eval("(1)")
end

private

def compile(source)
RubyVM::InstructionSequence.compile_yarp(source).eval
def test_yarp_eval(source)
ruby_eval = RubyVM::InstructionSequence.compile(source).eval
yarp_eval = RubyVM::InstructionSequence.compile_yarp(source).eval

assert_equal ruby_eval, yarp_eval
end
end
end
0