smparkes-johnson 1.1.2.3

data/test/johnson/spidermonkey/ruby_land_proxy_test.rb

@@ -0,0 +1,270 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class RubyLandProxyTest < Johnson::TestCase
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
+      end
+      
+      def test_constructing_a_proxy_directly_asplodes
+        assert_raise(Johnson::Error) { Johnson::SpiderMonkey::RubyLandProxy.new }
+      end
+      
+      def test_objects_get_wrapped_as_proxies
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, @runtime.evaluate("x = {}"))
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, @runtime.evaluate("new Object()"))
+      end
+      
+      def test_proxies_get_unwrapped_when_roundtripping
+        proxy = @runtime.evaluate("x = {}")
+        @runtime["y"] = proxy
+        assert(@runtime.evaluate("x === y"))
+      end
+
+      def test_reponds_to?
+        proxy = @runtime.evaluate("x = {}")
+        assert ! proxy.respond_to?(:foo)
+        assert ! proxy.respond_to?("foo")
+      end
+      
+      def test_array_indexable
+        proxy = @runtime.evaluate("var x = [1,2,3]; x")
+        assert_equal(1, proxy[0])
+        assert_equal(1, proxy['0'])
+
+        proxy[0] = 10
+        assert_js_equal(10, 'x[0]')
+      end
+      
+      def test_hash_indexable
+        proxy = @runtime.evaluate("var x = { 0: 1, 1: 2, 2: 3 }; x")
+        assert_equal(1, proxy[0])
+        assert_equal(1, proxy['0'])
+
+        proxy[0] = 10
+        assert_js_equal(10, 'x[0]')
+      end
+
+      def test_functions_get_wrapped_as_proxies
+        f = @runtime.evaluate("function() {}")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, f)
+        assert(f.function?)
+      end
+
+      def test_function?
+        f = @runtime.evaluate("function() {}")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, f)
+        assert(f.function?)
+
+        f = @runtime.evaluate("new Object()")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, f)
+        assert(!f.function?)
+      end
+      
+      def test_calling_non_functions_complains
+        o = @runtime.evaluate("new Object()")
+        assert_equal(false, o.respond_to?(:call))
+        assert_raise(NoMethodError) { o.call }
+      end
+      
+      def test_functions_can_be_called
+        f = @runtime.evaluate("function() { return 42; }")
+        assert_equal(42, f.call)
+      end
+      
+      def test_functions_can_be_called_with_args
+        f = @runtime.evaluate("function(x) { return x * 2; }")
+        assert_equal(84, f.call(42))
+      end
+      
+      def test_functions_can_be_used_as_procs
+        f = @runtime.evaluate("function(x) { return x * 2; }")
+        a = [1, 2, 3]
+        
+        assert_equal([2, 4, 6], a.collect(&f))
+      end
+      
+      def test_function_proxies_are_called_with_a_global_this
+        f = @runtime.evaluate("x = 42; function() { return this.x; }")
+        assert_equal(42, f.call)
+      end
+      
+      def test_can_be_indexed_by_string
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, proxy)
+        
+        assert_equal(42, proxy["foo"])
+        
+        proxy["foo"] = 99
+        proxy["bar"] = 42
+        
+        assert_js_equal(99, "x.foo")
+        assert_equal(99, proxy["foo"])
+        assert_equal(42, proxy["bar"])
+      end
+      
+      def test_can_be_indexed_by_symbol
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, proxy)
+        
+        assert_equal(42, proxy[:foo])
+        
+        proxy[:foo] = 99
+        proxy[:bar] = 42
+        
+        assert_js_equal(99, "x.foo")
+        assert_equal(99, proxy[:foo])
+        assert_equal(42, proxy[:bar])
+      end
+      
+      def test_multilevel_indexing_works
+        proxy = @runtime.evaluate("x = { foo: { bar: 42 , baz: function() { return 42 } } }")
+        assert_equal(42, proxy["foo"]["bar"])
+        assert_equal(42, proxy["foo"]["baz"].call)
+      end
+      
+      def test_respond_to_works
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert(!proxy.respond_to?(:bar))
+        assert(proxy.respond_to?(:foo))
+      end
+      
+      def test_respond_to_always_returns_true_for_assignment
+        proxy = @runtime.evaluate("x = {}")
+        assert(proxy.respond_to?(:bar=))
+      end
+      
+      def test_accessor
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert_equal(42, proxy.foo)
+      end
+      
+      def test_mutator
+        proxy = @runtime.evaluate("x = {}")
+        proxy.foo = 42
+        
+        assert_js_equal(42, "x.foo")
+        assert_equal(42, proxy.foo)
+      end
+      
+      def test_method_with_no_arguments
+        proxy = @runtime.evaluate("x = { foo: function() { return 42 } }")
+        assert_equal(42, proxy.foo)
+      end
+      
+      def test_method_with_one_argument
+        proxy = @runtime.evaluate("f = { f: function(x) { return x * 2 } }")
+        assert_equal(84, proxy.f(42))
+      end
+      
+      def test_method_with_multiple_arguments
+        proxy = @runtime.evaluate("x = { add: function(x, y) { return x + y } }")
+        assert_equal(42, proxy.add(40, 2))
+      end
+      
+      def test_supports_each_on_arrays
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        values = []
+        
+        proxy.each { |n| values << n }
+        assert_equal([1, 2, 3], values)
+      end
+      
+      def test_supports_each_on_things_that_arent_arrays
+        proxy = @runtime.evaluate("x = { foo: 'fooval', bar: 'barval' }; x[0] = 42; x")
+        values = {}
+        
+        proxy.each { |k, v| values[k] = v }
+        assert_equal({ 'foo' => 'fooval', 'bar' => 'barval', 0 => 42 }, values)
+      end
+      
+      def test_each_passes_an_exception
+        proxy = @runtime.evaluate("x = { foo: 'fooval', bar: 'barval' }; x[0] = 42; x")
+        values = {}
+        
+        assert_raise(RuntimeError) do
+          proxy.each do |k, v|
+            values[k] = v
+            raise "splat" if values.keys.size == 2
+          end
+        end
+        assert_equal({ 'foo' => 'fooval', 'bar' => 'barval' }, values)
+      end
+      
+      def test_is_enumerable
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        assert_kind_of(Enumerable, proxy)
+        
+        assert_equal([2, 4, 6], proxy.collect { |n| n * 2 })
+      end
+      
+      def test_has_a_length
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        assert_equal(3, proxy.length)
+      end
+      
+      def test_length_is_aliased_as_size
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        assert_equal(3, proxy.size)
+      end
+      
+      def test_length_for_arrays_ignores_non_numeric_properties
+        proxy = @runtime.evaluate("x = [1, 2, 3]; x['foo'] = 'bar'; x")
+        assert_equal(3, proxy.length)
+      end
+      
+      def test_length_for_objects_includes_all_properties
+        proxy = @runtime.evaluate("x = { foo: 'foo', bar: 'bar', 0: 42 }")
+        assert_equal(3, proxy.length)
+      end
+
+      def test_raises_in_js
+        @runtime["foo"] = lambda { raise RuntimeError.new("an exception") }
+        raised = @runtime.evaluate "x = null; try { foo(); } catch(ex) { x = ex; }; x"
+        assert_equal "#<RuntimeError: an exception>", raised.message
+      end
+
+      def test_uncaught_exceptions_have_decent_stack_trace
+        @runtime["foo"] = lambda { raise RuntimeError.new("an exception") }
+        line_number = __LINE__ - 1 # reference to previous line
+        begin
+          @runtime.evaluate "foo()"
+        rescue Exception => e
+          assert_equal "#<RuntimeError: an exception> at (none):1", e.message
+          assert_match %r/none:1\b/, e.backtrace[0]
+          assert_match %r/#{__FILE__}:#{line_number}\b/, e.backtrace[1]
+        else
+          flunk "exception was not raised"
+        end
+      end
+
+      def test_array_multiple_assignment
+        a = @runtime.evaluate("[1,2,3]")
+        x, y, z = a
+        
+        assert_equal(1, x)
+        assert_equal(2, y)
+        assert_equal(3, z)
+      end
+
+      # FIXME: If you uncomment this test, we get this error:
+      #
+      # JS API usage error: the address passed to JS_AddNamedRoot currently holds an
+      # invalid jsval.  This is usually caused by a missing call to JS_RemoveRoot.
+      # The root's name is "ruby_land_proxy.c[210]:native_call: proxy_value".
+      # Assertion failure: root_points_to_gcArenaList, at jsgc.c:2618
+      # 
+      # WTF?
+      #
+      # -Aaron
+      #
+      #def test_throwing_in_js_goes_to_ruby
+      #  func = @runtime.evaluate('function () { throw "foo"; }')
+      #  assert_raise(Johnson::Error) {
+      #    func.call
+      #  }
+      #end
+    end
+  end
+end

data/test/johnson/spidermonkey/runtime_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class RuntimeTest < Johnson::TestCase
+      def setup
+        @runtime = Johnson::SpiderMonkey::Runtime.new
+      end
+      
+      def test_can_create_more_than_one_without_barfing
+        assert_nothing_raised {
+          Johnson::SpiderMonkey::Runtime.new
+        }
+      end
+
+      def test_default_is_no_debugger
+        assert_equal false, @runtime.debugger?
+      end
+
+      def test_only_accepts_real_debugger_instance
+        assert_raises(TypeError) {
+          @runtime.debugger = 17
+        }
+        assert_raises(TypeError) {
+          @runtime.debugger = "Yes please!"
+        }
+        assert_raises(TypeError) {
+          @runtime.debugger = Object.new
+        }
+        assert_raises(TypeError) {
+          @runtime.debugger = @runtime
+        }
+      end
+
+      def test_reports_a_debugger_is_registered
+        @runtime.debugger = Johnson::SpiderMonkey::Debugger.new(nil)
+        assert @runtime.debugger?
+      end
+    end
+  end
+end

data/test/johnson/tracemonkey/context_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module TraceMonkey
+    class ContextTest < Johnson::TestCase
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::TraceMonkey::Runtime)
+      end
+      
+      def test_wraps_global_unfuckedly
+        assert_same(@runtime.global, @runtime.evaluate("this"))
+      end
+      
+      def test_provides_basic_runtime_interface
+        assert(@runtime.respond_to?(:evaluate))
+        assert(@runtime.respond_to?(:[]))
+        assert(@runtime.respond_to?(:[]=))
+      end
+    end
+  end
+end

data/test/johnson/tracemonkey/immutable_node_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+require 'stringio'
+
+module Johnson
+  module TraceMonkey
+    class ImmutableNodeTest < Johnson::TestCase
+      include Johnson::TraceMonkey
+
+      def test_initialize
+        node = nil
+        assert_nothing_raised {
+          node = ImmutableNode.new
+        }
+      end
+
+      def test_parse_some_shit
+        assert_nothing_raised {
+          node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
+        }
+      end
+
+      def test_index
+        node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
+        assert_equal(0, node.index)
+      end
+
+      def test_line
+        node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
+        assert_equal(0, node.line)
+      end
+    end
+  end
+end

data/test/johnson/tracemonkey/js_land_proxy_test.rb

@@ -0,0 +1,277 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module TraceMonkey
+    class JSLandProxyTest < Johnson::TestCase
+      module AModule
+      end
+      
+      class AClass
+        attr_reader :args
+        
+        def initialize(*args)
+          @args = args
+        end
+      end
+      
+      class Foo
+        class Inner
+        end
+        
+        def self.bar; 10; end
+
+        attr_accessor :bar
+        
+        def initialize
+          @bar = 10
+        end
+        
+        def x2(x)
+          x * 2
+        end
+        
+        def add(*args)
+          args.inject { |m,n| m += n }
+        end
+        
+        def xform(arg)
+          yield(arg)          
+        end
+      end
+      
+      class Indexable
+        def initialize
+          @store = {}
+        end
+        
+        def [](key)
+          @store[key]
+        end
+        
+        def []=(key, value)
+          @store[key] = value
+        end
+        
+        def key?(key)
+          @store.key?(key)
+        end
+      end
+
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::TraceMonkey::Runtime)
+      end
+
+      def test_find_constants
+        assert_js_equal($LOAD_PATH, "Ruby['$LOAD_PATH']")
+      end
+
+      def test_proxies_get_reused
+        @runtime["foo"] = @runtime["bar"] = Foo.new
+        assert_js_equal(true, "foo === bar")
+      end
+
+      def test_attributes_get_added_to_ruby
+        foo = @runtime["foo"] = Foo.new
+        assert !foo.respond_to?(:johnson)
+        @runtime.evaluate("foo.johnson = 'explode';")
+        assert foo.respond_to?(:johnson)
+        assert_equal('explode', foo.johnson)
+        assert_js_equal('explode', 'foo.johnson')
+        assert !Foo.new.respond_to?(:johnson)
+      end
+
+      def test_assign_function_as_attribute
+        foo = @runtime["foo"] = Foo.new
+        assert !foo.respond_to?(:johnson)
+        f = @runtime.evaluate("foo.johnson = function() { return 'explode'; }")
+        assert foo.respond_to?(:johnson)
+        assert_equal('explode', foo.johnson)
+        assert_js_equal('explode', 'foo.johnson()')
+        assert_js_equal(f, 'foo.johnson')
+        assert !Foo.new.respond_to?(:johnson)
+      end
+
+      def test_assign_function_as_attribute_with_this
+        foo = @runtime["foo"] = Foo.new
+        @runtime.evaluate("foo.ex_squared = function(x) { return this.x2(x); }")
+        assert_equal(4, foo.ex_squared(2))
+        @runtime.evaluate("foo.ex_squared = 20;")
+        assert_equal(20, foo.ex_squared)
+      end
+
+      def test_use_ruby_global_object
+        func = @runtime.evaluate("function(x) { return this.x2(x); }")
+        foo  = Foo.new
+        assert_equal(4, func.call_using(foo, 2))
+      end
+      
+      def test_proxies_roundtrip
+        @runtime["foo"] = foo = Foo.new
+        assert_same(foo, @runtime.evaluate("foo"))
+      end
+      
+      def test_proxies_classes
+        @runtime["Foo"] = Foo
+        assert_same(Foo, @runtime.evaluate("Foo"))
+      end
+      
+      def test_proxies_modules
+        @runtime["AModule"] = AModule
+        assert_same(AModule, @runtime.evaluate("AModule"))
+      end
+      
+      def test_proxies_hashes
+        @runtime["beatles"] = { "george" => "guitar" }
+        assert_equal("guitar", @runtime.evaluate("beatles['george']"))
+      end
+      
+      def test_getter_calls_0_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_getter_calls_indexer
+        @runtime["foo"] = indexable = Indexable.new
+        indexable["bar"] = 10
+        
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_getter_returns_nil_for_unknown_properties
+        @runtime["foo"] = Foo.new
+        assert_js_equal(nil, "foo.quux")
+      end
+
+      def test_setter_calls_key=
+        @runtime["foo"] = foo = Foo.new
+        assert_js_equal(42, "foo.bar = 42")
+        assert_equal(42, foo.bar)
+      end
+      
+      def test_setter_calls_indexer
+        @runtime["foo"] = indexable = Indexable.new
+        assert_js_equal(42, "foo.monkey = 42")
+        assert_equal(42, indexable["monkey"])
+      end
+      
+      def test_calls_attr_reader
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_calls_1_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.x2(5)")
+      end
+      
+      def test_calls_n_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.add(4, 2, 2, 1, 1)")
+      end
+      
+      def test_calls_class_method
+        @runtime["Foo"] = Foo
+        assert_js_equal(Foo.bar, "Foo.bar()")
+      end
+      
+      def test_accesses_consts
+        @runtime["Foo"] = Foo
+        assert_same(Foo::Inner, @runtime.evaluate("Foo.Inner"))
+      end
+            
+      def test_can_create_new_instances_in_js
+        @runtime["AClass"] = AClass
+        foo = @runtime.evaluate("AClass.new()")
+        assert_kind_of(AClass, foo)
+      end
+      
+      def test_class_proxies_provide_a_ctor
+        @runtime["AClass"] = AClass
+        foo = @runtime.evaluate("new AClass()")
+        assert_kind_of(AClass, foo)
+        
+        bar = @runtime.evaluate("new AClass(1, 2, 3)")
+        assert_equal([1, 2, 3], bar.args)
+      end
+      
+      def test_dwims_blocks
+        @runtime["foo"] = Foo.new
+        assert_js_equal(4, "foo.xform(2, function(x) { return x * 2 })")
+      end
+      
+      def test_dwims_blocks_for_0_arity_methods
+        @runtime[:arr] = [1, 2, 3]
+        assert_js_equal([2, 4, 6], "arr.collect(function(x) { return x * 2 })")
+      end
+      
+      def test_scope_for_with
+        assert_js_equal(84, "with (rb) { b + b }", :b => 1, :rb => { "b" => 42 })
+      end
+      
+      def test_lambdas_for_with
+        assert_js_equal(84, "with (rb) { b(42) }", :rb => { "b" => lambda { |x| x * 2 } })
+      end
+      
+      class MethodForWith
+        def b(x); x * 2; end
+      end
+      
+      def test_method_for_with
+        assert_js_equal(84, "with (rb) { b(42) }", :rb => MethodForWith.new)
+      end
+
+      def test_raises_string_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("throw 'my string';") }
+      end
+
+      def test_raises_object_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("throw { bad: true };") }
+      end
+
+      def test_raises_exception_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("undefinedValue();") }
+      end
+
+      def test_js_property_false_should_not_invoke
+        klass = Class.new do
+          def bar ; 10 ; end
+          def js_property?(name) ; false ; end
+        end
+        @runtime['foo'] = foo = klass.new
+        assert_equal foo.method(:bar), @runtime.evaluate("foo.bar")
+      end
+
+      def test_js_property_nil_should_not_invoke
+        klass = Class.new do
+          def bar ; 10 ; end
+          def js_property?(name) ; nil ; end
+        end
+        foo = klass.new
+        assert_js_equal(foo.method(:bar), "foo.bar", :foo => foo)
+      end
+
+      def test_js_property_true_should_invoke_0_arity
+        klass = Class.new do
+          def bar ; 10 ; end
+          def js_property?(name) ; true ; end
+        end
+        assert_js_equal(10, "foo.bar", :foo => klass.new)
+      end
+
+      def test_js_property_on_n_arity_should_raise_exception
+        klass = Class.new do
+          def bar(n) ; 10 + n ; end
+          def js_property?(name) ; true ; end
+        end
+        @runtime['foo'] = klass.new
+        begin
+          @runtime.evaluate("foo.bar")
+        rescue Exception => e
+          assert_match(/ArgumentError/, e.message)
+        else
+          flunk "did not raise an exception"
+        end
+      end
+    end
+  end
+end