require 'test/unit'

require 'test/jruby/test_helper'

require 'java'

class TestJavaExtension < Test::Unit::TestCase

include TestHelper

class TestParent < org.jruby.test.Parent

attr_accessor :result

def run(a)

@result = "TEST PARENT: #{a}"

end

end

java_import org.jruby.test.Worker

def test_overriding_method_in_java_superclass

w = Worker.new

p = TestParent.new

w.run_parent(p)

assert_equal "TEST PARENT: WORKER", p.result

end

import java.util.HashMap

import java.util.ArrayList

import java.util.HashSet

def test_set

set = HashSet.new

set.add(1)

set.add(2)

newSet = []

set.each { |x| newSet << x }

assert newSet.include?(1)

assert newSet.include?(2)

end

def test_comparable

short = Java::JavaLang::Short

one = short.new(1)

two = short.new(2)

three = short.new(3)

list = [three, two, one]

list.sort!

assert_equal [one, two, three], list

assert_equal ['a'.to_java, 'b'.to_java], [java.lang.String.new('b'), java.lang.String.new('a')].sort

end

def test_comparable_error

list = [3.to_java(:int), java.lang.Byte.new(2), 1, 0]

assert_raise(TypeError) { list.sort }

begin

[ java.lang.Short.new(1), java.lang.Integer.new(0) ].sort!

rescue => e

assert_instance_of TypeError, e

msg = 'java.lang.Short cannot be cast to java.lang.Integer'

unless msg.eql? e.message

msg = 'java.lang.Integer cannot be cast to java.lang.Short'

unless msg.eql? e.message

# IBM Java: #<TypeError: java.lang.Integer incompatible with java.lang.Short>

assert_match(/java.lang.Integer.*java.lang.Short/, e.message)

end

end

end

end

def test_map

map = HashMap.new

map.put('A','1')

map.put('C','3')

hash = Hash.new

map.each {|key, value| hash[key] = value }

assert_equal('1', hash['A'])

assert_equal('3', hash['C'])

end

def test_list

a = ArrayList.new

a << 3

a << 1

a << 2

# Java 8 defines one-arg sort on all List impls that masks ours. See #1249.

assert_equal([1, 2, 3], a.sort.to_a) if a.method(:sort).arity == 0

assert_equal([1, 2], a[1...3].to_a)

assert_equal([3, 1], a[0, 2].to_a)

assert_equal([3, 2], a.select {|e| e > 1 })

end

import org.jruby.test.TestHelper

import java.lang.RuntimeException

import java.lang.NullPointerException

import("org.jruby.test.TestHelper$TestHelperException") {"THException"}

def test_catch_java_exception_with_rescue

begin

TestHelper.throwTestHelperException

rescue THException => e

end

end

def test_catch_multiple_java_exceptions_picks_correct_rescue

begin

TestHelper.throwTestHelperException

rescue NullPointerException => e

flunk("Should not rescue")

rescue THException => e

end

end

def test_catch_java_exception_by_superclass

begin

TestHelper.throwTestHelperException

rescue RuntimeException => e

end

end

def test_catch_java_exception_by_ruby_native_exception

begin

TestHelper.throwTestHelperException

rescue NativeException => e

end

end

=begin See JRUBY-4677 for explanation of why this doesn't work yet

def test_catch_unwrapped_java_exception_as_a_RubyException

begin

raise java.lang.NullPointerException.new

rescue Exception => e

assert e.is_a?(Exception)

end

end

=end

def test_catch_unwrapped_java_exception_and_reraise

begin

raise java.lang.NullPointerException.new

rescue Exception => e

begin

raise # should not cause ClassCastException

rescue Exception => e

assert_equal java.lang.NullPointerException, e.class

end

end

end

BLUE = "blue"

GREEN = "green"

import org.jruby.javasupport.test.Color

def test_java_bean_conventions_in_ruby

# Java bean convention properties as attributes

color = Color.new(GREEN)

assert !color.isDark

color.dark = true

assert color.dark

assert color.dark?

assert_equal GREEN, color.color

color.color = BLUE

assert_equal BLUE, color.color

end

def test_java_class_name

assert_equal 'Java::OrgJrubyJavasupportTest::Color', Color.name

assert_equal 'org.jruby.javasupport.test.Color', Color.java_class.name

assert_equal 'Java::JavaLang::Runnable', java.lang.Runnable.name

assert_equal 'java.lang.Runnable', Java::JavaLang::Runnable.java_class.name

assert_equal 'Java::JavaLang::String', JString.name

assert_equal 'Java::JavaLang::Thread::State', Java::java.lang.Thread::State.name

# an enum class with custom code for each constant :

if JAVA_9 # since Java 9 the synthetic class name seems to get hidden away

assert_equal 'Java::JavaUtilConcurrent::TimeUnit', java.util.concurrent.TimeUnit::NANOSECONDS.class.name

assert_equal 'Java::JavaUtilConcurrent::TimeUnit', java.util.concurrent.TimeUnit::MICROSECONDS.class.name

else

assert_equal 'Java::JavaUtilConcurrent::TimeUnit::1', java.util.concurrent.TimeUnit::NANOSECONDS.class.name

assert_equal 'Java::JavaUtilConcurrent::TimeUnit::2', java.util.concurrent.TimeUnit::MICROSECONDS.class.name

end

assert java.util.concurrent.TimeUnit::MICROSECONDS.is_a?(java.util.concurrent.TimeUnit)

end

include_package 'org.jruby.javasupport.test'

include_package 'java.lang'

java_alias :JString, :String

def test_java_proxy_object_equivalence

room1 = Room.new("Bedroom")

room2 = Room.new("Bedroom")

room3 = Room.new("Bathroom")

assert(room1 == room2);

assert(room1 == room2.java_object);

assert(room1.java_object == room2.java_object)

assert(room1.java_object == room2)

assert(room1 != room3)

assert(room1 != room3.java_object)

assert(room1.java_object != room3.java_object)

assert(room1.java_object != room3)

assert(room1.java_object != "Bedroom")

assert("Bedroom" == room1.to_s)

assert(room1.to_s == "Bedroom")

assert(room1.equal?(room1))

assert(!room1.equal?(room2))

assert(JString.new("Bedroom").hashCode() == room1.hash())

assert(JString.new("Bathroom").hashCode() == room3.hash())

assert(room1.hash() != room3.hash())

end

def test_synchronized_method_available

# FIXME: this doesn't actually test that we're successfully synchronizing

obj = java.lang.Object.new

result = nil

assert_nothing_raised { result = obj.synchronized { "foo" } }

assert_equal("foo", result)

begin

obj.wait 1

rescue java.lang.IllegalMonitorStateException => e

assert e

else

fail "java.lang.IllegalMonitorStateException was not thrown"

end

assert_nothing_raised { obj.synchronized { obj.wait 1 } }

end

def test_java_interface_impl_with_block

ran = false

SimpleExecutor::WrappedByMethodCall.new.execute(Java::JavaLang::Runnable.impl { ran = true })

assert ran

end

def test_ruby_object_duck_typed_as_java_interface_when_passed_to_method

runnable = Object.new

def runnable.run; @ran ||= true; end

def runnable.ran; @ran; end

SimpleExecutor::WrappedByMethodCall.new.execute(runnable)

assert runnable.ran

end

def test_ruby_object_duck_typed_as_java_interface_when_passed_to_ctor

runnable = Object.new

def runnable.run; @ran ||= true; end

def runnable.ran; @ran; end

SimpleExecutor::WrappedByConstructor.new(runnable).execute

assert runnable.ran

end

def test_ruby_proc_passed_to_ctor_as_last_argument

ran = false

SimpleExecutor::WrappedByConstructor.new(proc { ran = true }).execute

assert ran

end

def test_ruby_proc_duck_typed_as_runnable

ran = false

SimpleExecutor::WrappedByMethodCall.new.execute(proc { ran = true })

assert ran

end

def test_ruby_proc_duck_typed_as_runnable_last_argument

ran = 0

SimpleExecutor::MultipleArguments.new.execute(2, proc { ran += 1 })

assert_equal 2, ran

end

def test_ruby_block_duck_typed_as_runnable

ran = false

SimpleExecutor::WrappedByMethodCall.new.execute { ran = true }

assert ran

end

def test_ruby_block_duck_typed_as_runnable_last_argument

ran = 0

SimpleExecutor::MultipleArguments.new.execute(3) { ran += 1 }

assert_equal 3, ran

end

def test_ruby_block_with_args_as_interface

file = java.io.File.new(".")

listing = file.list {|_,str| !!(str =~ /\./) }

assert listing.size >= 0

end

class RubyConcrete < org.jruby.test.Abstract

def protected_method

"Ruby overrides java!"

end

end

def test_overriding_protected_method

a = RubyConcrete.new

begin

assert_equal "Ruby overrides java!", a.call_protected

rescue Exception => e

flunk "Exception raised: #{e}"

end

end

def test_map_interface_to_array

hash = {"one"=>"two","three"=>"four"}

map = java.util.HashMap.new(hash)

assert_equal hash.to_a.sort, map.to_a.sort

end

def test_java_object_wrapper

wrapped1 = Java::JavaObject.wrap object = java.lang.StringBuilder.new

assert wrapped1.is_a? Java::JavaObject

assert_equal object, wrapped1

wrapped2 = Java::JavaObject.wrap java.lang.StringBuilder.new

assert_not_equal object, wrapped2

assert ! wrapped1.equal?(wrapped2)

wrapped3 = Java::JavaObject.wrap object

assert_equal wrapped1, wrapped3

assert wrapped1.equal?(wrapped3)

cal1 = java.util.Calendar.getInstance

cal1.setTime Java::JavaUtil::Date.new 0

cal2 = java.util.Calendar.getInstance

cal2.setTime Java::JavaUtil::Date.new 0

assert ! cal1.equal?(cal2)

wrapped1 = Java::JavaObject.wrap cal1

wrapped2 = Java::JavaObject.wrap cal2

assert wrapped2 == wrapped1

assert wrapped1.eql? wrapped2

assert ! wrapped1.equal?(wrapped2)

end

import org.jruby.test.Runner

def test_deadlock_due_to_java_object_wrapping_locking_on_java_instances

Runner.getRunner.runJob java.lang.Runnable.impl {

Thread.new do

runner = Runner.getRunner

assert runner.isRunning, "runner should be running"

end.join

}

end

end