jbarnette-johnson 1.0.0.200806240111

data/test/helper.rb

@@ -0,0 +1,58 @@
+require "rubygems"
+require "test/unit"
+
+%w(../lib ../ext/spidermonkey).each do |path|
+  $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), path)))
+end
+
+# If the test isn't running from Rake, make sure the extension's current.
+Rake rescue Dir.chdir(File.dirname(__FILE__) + "/..") { %x(rake extensions) }
+
+require "johnson"
+
+module Johnson
+  class TestCase < Test::Unit::TestCase
+    class TestLogger
+      def debug(string)
+        puts string
+      end
+    end
+
+    undef :default_test
+
+    def setup
+      @runtime = Johnson::Runtime.new
+      #@runtime.delegate.gc_zeal = 2
+      #@runtime.delegate.debugger = Johnson::SpiderMonkey::Debugger.new(TestLogger.new)
+    end
+    
+    def assert_js(expression, options={})
+      runtime = options[:runtime] || @runtime
+      assert(runtime.evaluate(expression), "Expected JS expression [#{expression}] to be true.")
+    end
+    
+    def assert_js_equal(expected, expression, options={})
+      runtime = options.delete(:runtime) || @runtime
+      options.each { |k, v| runtime[k.to_s] = v }
+      assert_equal(expected, runtime.evaluate(expression))
+    end
+  end
+
+  class NodeTestCase < Test::Unit::TestCase
+    include Johnson::Nodes
+  
+    undef :default_test
+    
+    def setup
+      @parser = Johnson::Parser
+    end
+  
+    def assert_sexp(expected, actual)
+      assert_equal(expected, actual.to_sexp)
+    end
+
+    def assert_ecma(expected, actual)
+      assert_equal(expected, actual.to_ecma)
+    end
+  end
+end

data/test/johnson/browser_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+require 'net/http'
+
+module Johnson
+  class BrowserTest < Johnson::TestCase
+    def setup
+      super
+      @runtime.evaluate('Johnson.require("johnson/browser");')
+    end
+
+    def test_set_location_returns_location
+      filename = "file://#{File.expand_path(__FILE__)}"
+
+      may_thread {
+        @runtime.evaluate("window.location = '#{filename}'")
+      }
+
+      uri = URI.parse(filename)
+      assert_equal(uri.to_s, @runtime.evaluate('window.location').to_s)
+    end
+
+    def test_set_location_with_url
+      file = File.expand_path(__FILE__) + "/../../assets/index.html"
+      filename = "file://#{File.expand_path(file)}"
+      may_thread {
+        @runtime.evaluate("window.location = '#{filename}'")
+      }
+      doc = @runtime.evaluate('window.document')
+      assert_not_nil(doc)
+    end
+
+    def may_thread(&block)
+      block.call
+      (Thread.list - [Thread.main]).each { |t| t.join }
+    end
+  end
+end

data/test/johnson/conversions/array_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class ArrayTest < Johnson::TestCase
+      def test_array_index_get
+        @runtime[:list] = [1, 2, 3, 4]
+        assert_equal(1, @runtime.evaluate("list[0]"))
+      end
+
+      def test_array_index_set
+        @runtime[:list] = []
+        @runtime.evaluate("list[0] = 42")
+        assert_equal(42, @runtime[:list][0])
+      end
+
+      def test_array_works_with_for_in
+        list = [1, 2, 3, 4]
+
+        @runtime['alert'] = lambda { |x| p x }
+        @runtime['list'] = list
+        @runtime.evaluate("
+          var new_list = [];
+          for(x in list) {
+            new_list.push(x + 1);
+          }
+        ")
+        assert_equal(list.map { |x| x + 1}, @runtime['new_list'].to_a)
+      end
+    end
+  end
+end

data/test/johnson/conversions/boolean_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class BooleanTest < Johnson::TestCase
+      def test_truthiness
+        @runtime[:v] = true
+        assert_same(true, @runtime.evaluate("v === true"))
+      end
+
+      def test_dirty_lies
+        @runtime[:v] = false
+        assert_same(false, @runtime.evaluate("v === true"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/callable_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class CallableTest < Johnson::TestCase
+      def test_proc_works_in_jsland
+        @runtime[:squared] = Proc.new { |x| x * x }
+        assert_js_equal(4, "squared(2)")
+      end
+      
+      def test_procs_roundtrip
+        @runtime[:k] = k = lambda { |x| x }
+        assert_same(k, @runtime.evaluate("k"))
+      end
+      
+      def test_proc_js_function_proxy_gets_reused
+        @runtime[:k] = k = lambda { |x| x }
+        @runtime[:kk] = k
+        assert_js("k === kk")
+      end
+      
+      class CallableThing
+        def call
+          "foo"
+        end
+      end
+      
+      def test_anything_with_a_call_method_can_be_called_as_a_method
+        @runtime[:c] = CallableThing.new
+        assert_js_equal("foo", "c()")
+      end
+    end
+  end
+end

data/test/johnson/conversions/file_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class FileTest < Johnson::TestCase
+      def test_read_file
+        File.open(__FILE__, 'rb') { |f|
+          @runtime[:foo] = f
+          assert_equal(f, @runtime.evaluate("foo"))
+          assert_equal(File.read(__FILE__), @runtime.evaluate("foo.read()"))
+        }
+      end
+    end
+  end
+end

data/test/johnson/conversions/nil_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class NilTest < Johnson::TestCase
+      def test_ruby_nil_is_js_null
+        @runtime[:v] = nil
+        assert_equal(true, @runtime.evaluate("v == null"))
+      end
+
+      def test_js_null_is_ruby_nil
+        assert_nil(@runtime.evaluate("null"))
+      end
+
+      def test_js_undefined_is_ruby_nil
+        assert_nil(@runtime.evaluate("undefined"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/number_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class NumberTest < Johnson::TestCase
+      def test_ruby_fixnum_in_js
+        @runtime[:v] = 42
+        
+        assert_js("v == 42")
+        assert_js_equal(42, "v")
+        assert_equal(42, @runtime[:v])
+      end
+      
+      def test_js_fixnum_in_ruby
+        fix = @runtime.evaluate("42")
+        assert_equal(42, fix)
+        assert_kind_of(Fixnum, fix)
+      end
+
+      def test_ruby_float_in_js
+        @runtime[:pi] = pi = 3.141592654
+        assert_js_equal(pi, "pi")
+        assert_in_delta(pi, @runtime.evaluate("pi"), 2 ** -20)
+      end
+      
+      def test_ruby_bignum_in_js
+        @runtime[:big] = big = 2 ** 200        
+        
+        assert_js_equal(big, "big")
+        assert_kind_of(Float, @runtime.evaluate("big"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/regexp_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class RegexpTest < Johnson::TestCase
+      def test_regex_converts
+        @runtime[:x] = /aaron/
+        @runtime[:y] = /john/i
+        assert @runtime.evaluate('"aaron".match(x)')
+        assert !@runtime.evaluate('"Aaron".match(x)')
+        assert @runtime.evaluate('"john".match(y)')
+        assert @runtime.evaluate('"John".match(y)')
+      end
+
+      def test_regex_roundtrips
+        @runtime[:x] = /aaron/
+        assert_equal(/aaron/, @runtime.evaluate('x'))
+
+        @runtime[:x] = /aaron/m
+        assert_equal(/aaron/m, @runtime.evaluate('x'))
+      end
+    end
+  end
+end

data/test/johnson/conversions/string_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class StringTest < Johnson::TestCase
+      def test_ruby_string_in_js
+        @runtime[:v] = "foo"
+        assert_js("'foo' == v")
+      end
+
+      def test_js_string_in_ruby
+        assert_equal("foo", @runtime.evaluate("'foo'"))
+      end
+
+      def test_roundtrip
+        @runtime[:v] = v = "hola"
+        assert_equal(v, @runtime.evaluate("v"))
+      end
+      
+      def test_strings_are_copies
+        @runtime[:v] = v = "hola"
+        assert_not_same(v, @runtime.evaluate("v"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/struct_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class StructTest < Johnson::TestCase
+      def test_use_struct
+        f = Struct.new(:phil_collins).new
+        f.phil_collins = 'awesome'
+        @runtime[:foo] = f
+        assert_equal(f, @runtime.evaluate('foo'))
+        assert_equal('awesome', @runtime.evaluate('foo.phil_collins'))
+      end
+    end
+  end
+end

data/test/johnson/conversions/symbol_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class SymbolTest < Johnson::TestCase
+      def test_symbols_are_interned
+        @runtime[:v] = :symbol
+        @runtime[:x] = :symbol
+
+        assert(@runtime.evaluate("v !== null && v === x"))
+      end
+
+      def test_ruby_symbol_roundtrips
+        @runtime[:v] = :foo
+        assert_equal(:foo, @runtime.evaluate("v"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/thread_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class ThreadTest < Johnson::TestCase
+      def test_manipulate_thread
+        thread = Thread.new { }
+        @runtime['thread'] = thread
+        assert_js_equal(false, "thread.send('alive?')")
+      end
+
+      def test_new_js_thread
+        @runtime.evaluate('function testing() { Ruby.sleep(10); }')
+        @runtime.evaluate('new Ruby.Thread(function() { testing(); })')
+      end
+
+      def test_js_thread_read_file
+        @runtime['filename'] = File.expand_path(__FILE__)
+        @runtime.evaluate('function testing() { Ruby.File.read(filename); }')
+        @runtime.evaluate('new Ruby.Thread(function() { testing(); })')
+      end
+    end
+  end
+end

data/test/johnson/error_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  class ErrorTest < Johnson::TestCase
+    def test_inherits_from_standard_error
+      assert(Johnson::Error < StandardError)
+    end
+  end
+end

data/test/johnson/extensions_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  module Extensions
+    class DefinePropertyTest < Johnson::TestCase
+      def setup
+        super
+        @runtime.evaluate("x = {}")
+      end      
+      
+      def test_object_can_define_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42)")
+        assert_js_equal(42, "x.answer")
+      end
+      
+      def test_object_can_define_unenumerable_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42)")
+        @runtime.evaluate <<-JS
+          y = [];
+          for(prop in x) if(prop == "answer") y.push(prop)
+        JS
+        assert_js("y.length == 0")
+      end
+      
+      def test_object_can_define_enumerable_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.ITERABLE)")
+        @runtime.evaluate <<-JS
+          y = [];
+          for(prop in x) if(prop == "answer") y.push(prop)
+        JS
+        assert_js("y.length == 1")
+      end
+      
+      def test_object_can_define_read_only_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.READ_ONLY)")
+        @runtime.evaluate("x.answer = 47")
+        assert_js_equal(42, "x.answer")
+      end
+      
+      def test_object_can_define_non_deletable_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.NON_DELETABLE)")
+        @runtime.evaluate("r = (delete x.answer)")
+        assert_js_equal(false, "r")
+        assert_js_equal(42, "x.answer")
+      end
+      
+      def test_object_can_define_mixed_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.NON_DELETABLE | Object.READ_ONLY)")
+        @runtime.evaluate("r = (delete x.answer)")
+        @runtime.evaluate("x.answer = 47")
+        assert_js_equal(false, "r")
+        assert_js_equal(42, "x.answer")
+      end      
+    end
+  end
+end