datawire_mdk 2.0.5

data/lib/quark/test.rb

@@ -0,0 +1,766 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.test; Test; end
+module Test
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+require_relative '../quark' # 0 () ('quark',)
+require_relative 'concurrent' # 1 () ()
+
+
+def self.TestInitializer; TestInitializer; end
+class TestInitializer < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_test_TestInitializer_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getValue()
+        
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.test.Test }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.test.TestInitializer"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+TestInitializer.unlazy_statics
+
+def self.red(str)
+    
+    return (("\u001b[31;1m") + (str)) + ("\u001b[0m")
+
+
+    nil
+end
+
+def self.green(str)
+    
+    return (("\u001b[32;1m") + (str)) + ("\u001b[0m")
+
+
+    nil
+end
+
+def self.bold(str)
+    
+    return (("\u001b[1m") + (str)) + ("\u001b[0m")
+
+
+    nil
+end
+
+def self.heading(str)
+    
+    padding = "="
+    target_width = 78
+    res = (((padding) + (" ")) + (str)) + (" ")
+    count = ((target_width) - ((res).size)) / ((padding).size)
+    block = (padding) * [0, ((count) / (2))].max
+    extra = ""
+    if (((count) % (2)) == (1))
+        extra = padding
+    end
+    return ::Quark.quark.test.bold(((((block) + (res)) + (block)) + (extra)).strip)
+
+
+    nil
+end
+
+def self.Test; Test; end
+class Test < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :name, :checks, :successes, :failures
+    extend ::DatawireQuarkCore::Static
+
+    static ctx: -> { ::DatawireQuarkCore::TLS.new(::Quark.quark.test.TestInitializer.new()) }
+    static quark_test_Test_ref: -> { nil }
+
+
+
+    def initialize(name)
+        
+        self.__init_fields__
+        (self).name = name
+
+        nil
+    end
+
+
+
+
+    def self.current()
+        
+        return ::Quark.quark.test.Test.ctx.getValue()
+
+        nil
+    end
+
+    def match(filters)
+        
+        if (((filters) == (nil)) || (((filters).size) == (0)))
+            return true
+        end
+        idx = 0
+        while ((idx) < ((filters).size)) do
+            filter = (filters)[idx]
+            if ((((@name).index(filter) or -1)) >= (0))
+                return true
+            end
+            idx = (idx) + (1)
+        end
+        return false
+
+        nil
+    end
+
+    def start()
+        
+        ::Quark.quark.test.Test.ctx.setValue(self)
+
+        nil
+    end
+
+    def stop()
+        
+        result = (((((@name) + (" [")) + ((@checks).to_s)) + (" checks, ")) + (((@failures).size).to_s)) + (" failures]")
+        if (((@failures).size) > (0))
+            ::DatawireQuarkCore.print(::Quark.quark.test.red(result))
+        else
+            ::DatawireQuarkCore.print(::Quark.quark.test.bold(result))
+        end
+        idx = 0
+        while ((idx) < ((@successes).size)) do
+            ::DatawireQuarkCore.print(::Quark.quark.test.green(("  PASS: ") + ((@successes)[idx])))
+            idx = (idx) + (1)
+        end
+        idx = 0
+        while ((idx) < ((@failures).size)) do
+            ::DatawireQuarkCore.print(::Quark.quark.test.red(("  FAIL: ") + ((@failures)[idx])))
+            idx = (idx) + (1)
+        end
+        ::Quark.quark.test.Test.ctx.setValue(nil)
+
+        nil
+    end
+
+    def check(value, message)
+        
+        @checks = (@checks) + (1)
+        if (value)
+            (@successes) << (message)
+        else
+            (@failures) << (message)
+        end
+        return value
+
+        nil
+    end
+
+    def fail(message)
+        
+        self.check(false, message)
+
+        nil
+    end
+
+    def run()
+        
+        nil
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.test.Test"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("ctx"))
+            return ::Quark.quark.test.Test.ctx
+        end
+        if ((name) == ("name"))
+            return (self).name
+        end
+        if ((name) == ("checks"))
+            return (self).checks
+        end
+        if ((name) == ("successes"))
+            return (self).successes
+        end
+        if ((name) == ("failures"))
+            return (self).failures
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("ctx"))
+            ::Quark.quark.test.Test.ctx = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
+        end
+        if ((name) == ("name"))
+            (self).name = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("checks"))
+            (self).checks = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("successes"))
+            (self).successes = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("failures"))
+            (self).failures = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.name = nil
+        self.checks = 0
+        self.successes = ::DatawireQuarkCore::List.new([])
+        self.failures = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+
+end
+Test.unlazy_statics
+
+def self.SafeMethodCaller; SafeMethodCaller; end
+class SafeMethodCaller < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :method, :test
+    extend ::DatawireQuarkCore::Static
+
+    static useSafeCalls: -> { true }
+    static quark_test_SafeMethodCaller_ref: -> { nil }
+
+
+
+    def initialize(method, test)
+        
+        self.__init_fields__
+        (self).method = method
+        (self).test = test
+
+        nil
+    end
+
+
+
+
+    def call(ignore)
+        
+        @method.invoke(@test, ::DatawireQuarkCore::List.new([]))
+        return true
+
+        nil
+    end
+
+    def self.callMethod(method, test)
+        
+        if (::Quark.quark.test.SafeMethodCaller.useSafeCalls)
+            callable = ::Quark.quark.test.SafeMethodCaller.new(method, test)
+            return ::DatawireQuarkCore.cast(::Quark.quark.concurrent.Context.runtime().callSafely(callable, false)) { ::Object }
+        end
+        method.invoke(test, ::DatawireQuarkCore::List.new([]))
+        return true
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.test.SafeMethodCaller"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("useSafeCalls"))
+            return ::Quark.quark.test.SafeMethodCaller.useSafeCalls
+        end
+        if ((name) == ("method"))
+            return (self).method
+        end
+        if ((name) == ("test"))
+            return (self).test
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("useSafeCalls"))
+            ::Quark.quark.test.SafeMethodCaller.useSafeCalls = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("method"))
+            (self).method = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.Method }
+        end
+        if ((name) == ("test"))
+            (self).test = value
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.method = nil
+        self.test = nil
+
+        nil
+    end
+
+
+end
+SafeMethodCaller.unlazy_statics
+
+def self.MethodTest; MethodTest; end
+class MethodTest < ::Quark.quark.test.Test
+    attr_accessor :klass, :method
+    extend ::DatawireQuarkCore::Static
+
+    static quark_test_MethodTest_ref: -> { nil }
+
+
+
+    def initialize(klass, method)
+        
+        super(((klass.getName()) + (".")) + (method.getName()))
+        (self).klass = klass
+        (self).method = method
+
+        nil
+    end
+
+
+
+
+    def run()
+        
+        setup = @klass.getMethod("setup")
+        teardown = @klass.getMethod("teardown")
+        test = @klass.construct(::DatawireQuarkCore::List.new([]))
+        if ((setup) != (nil))
+            if (!(::Quark.quark.test.SafeMethodCaller.callMethod(setup, test)))
+                ::Quark.quark.test.fail("setup invocation crashed")
+            end
+        end
+        if (!(::Quark.quark.test.SafeMethodCaller.callMethod(@method, test)))
+            ::Quark.quark.test.fail("test invocation crashed")
+        end
+        if ((teardown) != (nil))
+            if (!(::Quark.quark.test.SafeMethodCaller.callMethod(teardown, test)))
+                ::Quark.quark.test.fail("teardown invocation crashed")
+            end
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.test.MethodTest"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("ctx"))
+            return ::Quark.quark.test.Test.ctx
+        end
+        if ((name) == ("name"))
+            return (self).name
+        end
+        if ((name) == ("checks"))
+            return (self).checks
+        end
+        if ((name) == ("successes"))
+            return (self).successes
+        end
+        if ((name) == ("failures"))
+            return (self).failures
+        end
+        if ((name) == ("klass"))
+            return (self).klass
+        end
+        if ((name) == ("method"))
+            return (self).method
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("ctx"))
+            ::Quark.quark.test.Test.ctx = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::TLS }
+        end
+        if ((name) == ("name"))
+            (self).name = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("checks"))
+            (self).checks = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("successes"))
+            (self).successes = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("failures"))
+            (self).failures = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("klass"))
+            (self).klass = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("method"))
+            (self).method = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.Method }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.klass = nil
+        self.method = nil
+
+        nil
+    end
+
+
+end
+MethodTest.unlazy_statics
+
+def self.check(value, message)
+    
+    return ::Quark.quark.test.Test.current().check(value, message)
+
+
+    nil
+end
+
+def self.checkEqual(expected, actual)
+    
+    return ::Quark.quark.test.Test.current().check((expected) == (actual), ((("expected ") + ((expected).to_s)) + (" got ")) + ((actual).to_s))
+
+
+    nil
+end
+
+def self.fail(message)
+    
+    ::Quark.quark.test.Test.current().check(false, message)
+
+
+    nil
+end
+
+def self.checkOneOf(expected, actual)
+    
+    message = "Expected one of ["
+    idx = 0
+    success = false
+    while ((idx) < ((expected).size)) do
+        if ((idx) != (0))
+            message = (message) + (", ")
+        end
+        message = (message) + (((expected)[idx]).to_s)
+        if (((expected)[idx]) == (actual))
+            success = true
+        end
+        idx = (idx) + (1)
+    end
+    message = ((message) + ("] got ")) + ((actual).to_s)
+    return ::Quark.quark.test.check(success, message)
+
+
+    nil
+end
+
+def self.Harness; Harness; end
+class Harness < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :pkg, :tests, :filtered
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark_test_Test__ref: -> { nil }
+    static quark_test_Harness_ref: -> { nil }
+
+
+
+    def initialize(pkg)
+        
+        self.__init_fields__
+        (self).pkg = pkg
+
+        nil
+    end
+
+
+
+
+    def collect(filters)
+        
+        names = ::DatawireQuarkCore::List.new((::Quark.quark.reflect.QuarkClass.classes).keys)
+        (names).sort!
+        idx = 0
+        pfx = (@pkg) + (".")
+        while ((idx) < ((names).size)) do
+            name = (names)[idx]
+            if (((name).start_with?(pfx)) && ((name).end_with?("Test")))
+                klass = ::Quark.quark.reflect.QuarkClass.get(name)
+                methods = klass.getMethods()
+                jdx = 0
+                while ((jdx) < ((methods).size)) do
+                    meth = (methods)[jdx]
+                    mname = meth.getName()
+                    if (((mname).start_with?("test")) && (((meth.getParameters()).size) == (0)))
+                        test = ::Quark.quark.test.MethodTest.new(klass, meth)
+                        if (test.match(filters))
+                            (@tests) << (test)
+                        else
+                            @filtered = (@filtered) + (1)
+                        end
+                    end
+                    jdx = (jdx) + (1)
+                end
+            end
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def list()
+        
+        idx = 0
+        while ((idx) < ((@tests).size)) do
+            test = (@tests)[idx]
+            ::DatawireQuarkCore.print((test).name)
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    ##
+    # Run the tests, return number of failures.
+
+    def run()
+        
+        ::DatawireQuarkCore.print(::Quark.quark.test.heading("starting tests"))
+        idx = 0
+        failures = 0
+        while ((idx) < ((@tests).size)) do
+            test = (@tests)[idx]
+            test.start()
+            test.run()
+            test.stop()
+            if ((((test).failures).size) > (0))
+                failures = (failures) + (1)
+            end
+            idx = (idx) + (1)
+        end
+        passed = ((@tests).size) - (failures)
+        ::DatawireQuarkCore.print(::Quark.quark.test.heading("stopping tests"))
+        result = ((((((("Total: ") + ((((@tests).size) + (@filtered)).to_s)) + (", Filtered: ")) + ((@filtered).to_s)) + (", Passed: ")) + ((passed).to_s)) + (", Failed: ")) + ((failures).to_s)
+        if ((failures) > (0))
+            ::DatawireQuarkCore.print(::Quark.quark.test.red(result))
+        else
+            ::DatawireQuarkCore.print(::Quark.quark.test.green(result))
+        end
+        return failures
+
+        nil
+    end
+
+    def json_report()
+        
+        ::DatawireQuarkCore.print("=============================== json report ===============================")
+        idx = 0
+        report = ::DatawireQuarkCore::JSONObject.new
+        while ((idx) < ((@tests).size)) do
+            item = ::DatawireQuarkCore::JSONObject.new
+            test = (@tests)[idx]
+            f = 0
+            failures = ::DatawireQuarkCore::JSONObject.new
+            while ((f) < (((test).failures).size)) do
+                failures.setListItem(f, ::DatawireQuarkCore::JSONObject.new.setString(((test).failures)[f]))
+                f = (f) + (1)
+            end
+            (item).setObjectItem(("name"), (::DatawireQuarkCore::JSONObject.new.setString((test).name)))
+            (item).setObjectItem(("checks"), (::DatawireQuarkCore::JSONObject.new.setNumber((test).checks)))
+            (item).setObjectItem(("failures"), (failures))
+            report.setListItem(idx, item)
+            idx = (idx) + (1)
+        end
+        ::DatawireQuarkCore.print(report.toString())
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.test.Harness"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("pkg"))
+            return (self).pkg
+        end
+        if ((name) == ("tests"))
+            return (self).tests
+        end
+        if ((name) == ("filtered"))
+            return (self).filtered
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("pkg"))
+            (self).pkg = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("tests"))
+            (self).tests = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("filtered"))
+            (self).filtered = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.pkg = nil
+        self.tests = ::DatawireQuarkCore::List.new([])
+        self.filtered = 0
+
+        nil
+    end
+
+
+end
+Harness.unlazy_statics
+
+def self.testPackages(packages, filters, emitJson)
+    
+    h = ::Quark.quark.test.Harness.new("")
+    total_failures = 0
+    idx = 0
+    while ((idx) < ((packages).size)) do
+        (h).pkg = (packages)[idx]
+        h.collect(filters)
+        idx = (idx) + (1)
+    end
+    total_failures = h.run()
+    if (emitJson)
+        h.json_report()
+    end
+    return total_failures
+
+
+    nil
+end
+
+def self.run(args)
+    
+    pkg = (args)[0]
+    filters = ::DatawireQuarkCore::List.new([])
+    list = false
+    json = false
+    idx = 1
+    while ((idx) < ((args).size)) do
+        arg = (args)[idx]
+        if ((arg) == ("-l"))
+            list = true
+        else
+            if ((arg) == ("--json"))
+                json = true
+            else
+                if ((arg) == ("--unsafe"))
+                    ::Quark.quark.test.SafeMethodCaller.useSafeCalls = false
+                else
+                    (filters) << (arg)
+                end
+            end
+        end
+        idx = (idx) + (1)
+    end
+    if (list)
+        h = ::Quark.quark.test.Harness.new(pkg)
+        h.collect(filters)
+        h.list()
+    else
+        ::DatawireQuarkCore.print(::Quark.quark.test.bold(("Running: ") + ((args).join(" "))))
+        failures = ::Quark.quark.test.testPackages(::DatawireQuarkCore::List.new([pkg]), filters, json)
+        if ((failures) > (0))
+            ::Quark.quark.concurrent.Context.runtime().fail("Test run failed.")
+        end
+    end
+
+
+    nil
+end
+end # module Test
+end # module Quark
+end # module Quark