therubyracer-freebsd 0.10.1

data/spec/ext/object_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe V8::C::Object do
+  include V8::ExtSpec
+
+  it "always returns a copy of the same object if it is the same object" do
+    v8_eval('var o = new Object()')
+    v8_eval('o').should be(v8_eval('o'))
+  end
+end

data/spec/ext/string_spec.rb

@@ -0,0 +1,11 @@
+
+require 'spec_helper'
+
+describe V8::C::String do
+  include V8::ExtSpec
+  
+  describe "a string with null bytes" do
+    subject {c::String::New("foo\0bar")}
+    its(:Utf8Value) {should eql "foo\0bar"}
+  end
+end

data/spec/ext/try_catch_spec.rb

@@ -0,0 +1,60 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+include V8
+
+describe C::TryCatch do
+
+  before {@lock = C::Locker.new;@cxt = C::Context::New();}
+  after {@cxt.Dispose(); @lock.delete}
+
+  it "does not allow instance creation by default" do
+    lambda {
+     C::TryCatch.new
+    }.should raise_error
+  end
+
+  it "will do nothing if not passed a block" do
+    C::TryCatch.try.should == nil
+  end
+
+  it "executes a block in the context of a C++ stack frame" do
+    C::TryCatch.try do |catch|
+      catch.HasCaught().should be(false)
+    end
+  end
+
+  it "raises an erro if you try to access it outside of its scope" do
+    tc = C::TryCatch.try do |catch|
+      catch.tap {}
+    end
+    lambda {
+      tc.HasCaught()
+    }.should raise_error(ScriptError)
+  end
+
+    it "doesn't segfault when an error is raised in a javascript function on a native prototype" do
+      constructor = Class.new
+      constructor.class_eval do
+        def detonate(*a)
+          raise "BOOM!"
+        end
+      end
+      V8::Context.new do |cxt|
+        cxt['Boom'] = constructor
+        cxt['puts'] = method(:puts)
+        danger = <<-JS
+  Boom.prototype.boom = function() {
+    this.detonate()
+  }
+  var go = new(Boom)()
+  try {
+    go.boom()
+  } catch (e) {
+  }
+  go.boom()
+  JS
+        expect {cxt.eval(danger, 'danger.js')}.should raise_error(V8::JSError)
+      end
+    end
+
+end

data/spec/redjs_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'redjs/load_specs'
+module RedJS
+  Context = V8::Context
+  Error = V8::JSError
+end
+describe V8::Context do
+  it_behaves_like 'RedJS::Context'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+
+require 'v8'
+require 'erb'
+require Pathname(__FILE__).dirname.join('ext/ext_spec_helper')
+require Pathname(__FILE__).dirname.join('../specmem/spec_helper')
+def rputs(msg)
+  puts "<pre>#{ERB::Util.h(msg)}</pre>"
+  $stdout.flush
+end

data/spec/v8/error_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe V8::JSError do
+
+  before(:each) do
+    @cxt = V8::Context.new
+    @cxt['one'] = lambda do
+      @cxt.eval('two()', 'one.js')
+    end
+    @cxt['two'] = lambda do
+      @cxt.eval('three()', 'two.js')
+    end
+  end
+
+  it "captures a message without over nesting when the error is an error" do
+    throw! do |e|
+      e.message.should == "BOOM!"
+    end
+  end
+
+  it "captures the js message without over nesting when the error is a normal object" do
+    throw!('{foo: "bar"}') do |e|
+      e.message.should == "[object Object]"
+    end
+    throw!('{message: "bar"}') do |e|
+      e.message.should == "bar"
+    end
+  end
+
+  it "captures a thrown value as the message" do
+    throw!('"BOOM!"') do |e|
+      e.message.should == "BOOM!"
+    end
+    throw!('6') do |e|
+      e.message.should == '6'
+    end
+  end
+
+  it "has a reference to the root javascript cause" do
+    throw!('"I am a String"') do |e|
+      e.should_not be_in_ruby
+      e.should be_in_javascript 
+      e.value.should == "I am a String"
+    end
+  end
+
+  it "has a reference to the root ruby cause if one exists" do
+    StandardError.new("BOOM!").tap do |bomb|
+      @cxt['boom'] = lambda do
+        raise bomb
+      end
+      lambda {
+        @cxt.eval('boom()', 'boom.js')
+      }.should(raise_error do |raised|
+        raised.should be_in_ruby 
+        raised.should_not be_in_javascript 
+        raised.value.should be(bomb)
+      end)
+    end
+  end
+
+  describe "backtrace" do
+
+    it "is mixed with ruby and javascript" do
+      throw! do |e|
+        e.backtrace.first.should == "at three.js:1:7"
+        e.backtrace[1].should =~ /error_spec.rb/
+        e.backtrace[2].should == "at two.js:1:1"
+        e.backtrace[3].should =~ /error_spec.rb/
+        e.backtrace[4].should == "at one.js:1:1"
+      end
+    end
+    
+    it "can be set to show only ruby frames" do
+      throw! do |e|
+        e.backtrace(:ruby).each do |frame|
+          frame.should =~ /(\.rb|):\d+/
+        end
+      end
+    end
+    
+    it "can be set to show only javascript frames" do
+      throw! do |e|
+        e.backtrace(:javascript).each do |frame|
+          frame.should =~ /\.js:\d:\d/
+        end
+      end
+    end
+    
+    it "includes a mystery marker when the original frame is unavailable because what got thrown wasn't an error" do
+      throw!("6") do |e|
+        e.backtrace.first.should == 'at three.js:1:1'
+      end
+    end
+    
+    it "has a source name and line number when there is a javascript SyntaxError" do
+      lambda do
+        @cxt.eval(<<-INVALID, 'source.js')
+"this line is okay";
+"this line has a syntax error because it ends with a colon":
+"this line is also okay";
+"how do I find out that line 2 has the syntax error?";
+INVALID
+      end.should raise_error(V8::JSError) {|error|
+        error.backtrace.first.should == 'at source.js:2:60'
+      }
+    end
+
+    it "can start with ruby at the bottom" do
+      @cxt['boom'] = lambda do
+        raise StandardError, "Bif!"
+      end
+      lambda {
+        @cxt.eval('boom()', "boom.js")
+      }.should(raise_error {|e|
+        e.backtrace.first.should =~ /error_spec\.rb/
+        e.backtrace[1].should =~ /boom.js/
+      })
+    end
+  end
+  
+  
+  def throw!(js = "new Error('BOOM!')", &block)
+    @cxt['three'] = lambda do
+      @cxt.eval("throw #{js}", 'three.js')
+    end
+    lambda do
+      @cxt['one'].call()
+    end.should(raise_error(V8::JSError, &block))
+  end
+end

data/spec/v8/portal/proxies_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe V8::Portal::Proxies do
+  include V8::ExtSpec
+
+
+  context "for Ruby objects which are embedded into javascript" do
+
+    it "allows you to resolve the Ruby object's JavaScript proxy" do
+      js_proxy = c::Object::New()
+      rb_object = Object.new
+      subject.register_javascript_proxy js_proxy, :for => rb_object
+      subject.rb_object_2_js_proxy(rb_object).should be(js_proxy)
+      subject.js_proxy_2_rb_object(js_proxy).should be(rb_object)
+    end
+
+    it "requires a Ruby object which is the actual object that is proxied" do
+      expect {subject.register_javascript_proxy c::Object::New()}.should raise_error(ArgumentError)
+    end
+
+    it "can only register proxies which are low-level JavaScript objects" do
+      expect {subject.register_javascript_proxy Object.new, :for => Object.new}.should raise_error(ArgumentError)
+    end
+
+    it "is only allowed to have a single JavaScript proxy" do
+      rb_object = Object.new
+      subject.register_javascript_proxy c::Object::New(), :for => rb_object
+      expect {subject.register_javascript_proxy c::Object::New(), :for => rb_object}.should raise_error(V8::Portal::Proxies::DoubleProxyError)
+    end
+  end
+
+  context "for a JavaScript objects which are embedded into Ruby" do
+
+    it "allows you to resolve the JavaScript object's Ruby proxy" do
+      rb_proxy = Object.new
+      js_object = c::Object::New()
+      subject.register_ruby_proxy rb_proxy, :for => js_object
+      subject.js_object_2_rb_proxy(js_object).should be(rb_proxy)
+      subject.rb_proxy_2_js_object(rb_proxy).should be(js_object)
+    end
+
+    it "requires a JavaScript low level javascript object as the actual object that is proxied" do
+      expect {subject.register_javascript_proxy Object.new, :for => c::Object::New()}.should raise_error(ArgumentError)
+    end
+
+    it "will not a proxy twice if the proxy creator block actually registers the proxy inside it" do
+      target = Object.new
+      proxy = c::Object::New()
+      expect {subject.rb2js(target) do |object|
+        subject.register_javascript_proxy(proxy, :for => object)
+        c::Object::New()
+      end}.should_not raise_error
+      subject.rb2js(target).should be(proxy)
+    end
+
+    context "looking up a Ruby object from a random JavaScript object" do
+      it "checks first if it's a native Ruby object with a javascript proxy" do
+        target = Object.new
+        proxy = c::Object::New()
+        subject.register_javascript_proxy proxy, :for => target
+        subject.js2rb(proxy).should be(target)
+      end
+      it "then sees if maybe it's a native JavaScript that has a Ruby proxy" do
+        target = c::Object::New()
+        proxy = Object.new
+        subject.register_ruby_proxy proxy, :for => target
+        subject.js2rb(target).should be(proxy)
+      end
+      it "will assume that it is a native JavaScript object that needs a Ruby proxy if no corresponding Ruby object can be found" do
+        js = c::Object::New()
+        proxy = subject.js2rb(js) do |target|
+          {:target => target}
+        end
+        subject.js2rb(js).should be(proxy)
+      end
+    end
+
+    context "looking up a JavaScript object from a random Ruby object" do
+      it "checks first if it's a native JavaScript object with a Ruby proxy" do
+        target = c::Object::New()
+        proxy = Object.new
+        subject.register_ruby_proxy proxy, :for => target
+        subject.rb2js(proxy).should be(target)
+      end
+
+      it "then sees if maybe it's a native Ruby object that has a JavaScript proxy" do
+        target = Object.new
+        proxy = c::Object::New()
+        subject.register_javascript_proxy proxy, :for => target
+        subject.rb2js(target).should be(proxy)
+      end
+
+      it "assumes that it is a native Ruby object that needs a JavaScript proxy if no corresponding JavaScript object can be found" do
+        rb = Object.new
+        proxy = nil
+        js = subject.rb2js(rb) do |target|
+          target.should be(rb)
+          proxy = c::Object::New()
+        end
+        proxy.should_not be_nil
+        js.should be(proxy)
+        subject.rb2js(rb).should be(proxy)
+      end
+    end
+  end
+end

data/specmem/handle_memspec.rb

@@ -0,0 +1,41 @@
+
+require 'spec_helper'
+
+describe V8::C::Handle do
+  include V8::MemSpec
+  context "A JavaScript Object reflected into Ruby" do
+
+    before do
+      @weakref_callback = WeakrefCallback.new
+    end
+
+    it "has a strong reference from the ruby side, which is not released until the Ruby reference goes away" do
+      handle = c::Handle::New(object = c::Object::New())
+      handle.MakeWeak(nil, @weakref_callback)
+      ruby_gc do
+        v8_gc
+        @weakref_callback.should_not have_been_invoked
+        handle.should_not be_dead
+      end
+      ruby_gc do
+        object = nil
+        v8_gc
+        @weakref_callback.should have_been_invoked
+        handle.should be_dead
+      end
+    end
+
+    private
+
+    class WeakrefCallback
+
+      def call(value, parameters)
+        @invoked = true
+      end
+
+      def has_been_invoked?
+        @invoked
+      end
+    end
+  end
+end

data/specmem/object_memspec.rb

@@ -0,0 +1,14 @@
+
+require 'spec_helper'
+
+describe V8::C::Object do
+  include V8::MemSpec
+  it "will return a new peer and not barf if the old peer has been garbage collected" do
+    v8_eval('var o = {foo: "bar"}')
+    old_id = v8_eval('o').object_id
+    ruby_gc do
+      v8_eval('o').Get(c::String::New("foo")).Utf8Value().should == "bar"
+      v8_eval('o').object_id.should_not be(old_id)
+    end
+  end
+end

data/specmem/proxies_memspec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe V8::Portal::Proxies do
+  include V8::MemSpec
+  
+  context "A Ruby object embedded into JavaScript" do
+    it "holds a hard reference to any ruby object which is linked to a javascript proxy" do
+      subject.register_javascript_proxy c::Object::New(), :for => Object.new
+      ruby_gc do
+        subject.should_not be_empty
+      end
+    end
+
+    it "releases the hard reference if its corresponding javascript object has been garbage collected" do
+      ruby_gc do
+        rb_object = Object.new
+        js_proxy = c::Object::New()
+        subject.should be_empty
+        subject.register_javascript_proxy js_proxy, :for => rb_object
+        rb_object = nil
+        subject.should_not be_empty
+        v8_gc()
+      end
+      subject.should be_empty
+    end
+  end
+
+  context "A JavaScript object embedded into Ruby" do
+    it "holds a hard reference to any JavaScript object which is linked to a Ruby proxy" do
+      proxy = Object.new
+      subject.register_ruby_proxy proxy, :for => c::Object::New()
+      ruby_gc do
+        subject.should_not be_empty
+      end
+    end
+
+    it "clears any strong references to the JavaScript object when it's Ruby proxy is garbage collected" do
+      subject.register_ruby_proxy Object.new, :for => c::Object::New()
+      subject.should_not be_empty
+      ruby_gc do
+        v8_gc
+        GC.start
+        v8_gc
+      end
+      subject.should be_empty
+    end
+  end
+
+end