datawire_mdk 2.0.5

data/lib/quark/error.rb

@@ -0,0 +1,84 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.error; Error; end
+module Error
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+
+
+def self.Error; Error; end
+class Error < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :message
+    extend ::DatawireQuarkCore::Static
+
+    static quark_error_Error_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        self.__init_fields__
+        (self).message = message
+
+        nil
+    end
+
+
+
+
+    def getMessage()
+        
+        return @message
+
+        nil
+    end
+
+    def toString()
+        
+        return (("Error(") + ((self).message)) + (")")
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.error.Error"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("message"))
+            return (self).message
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.message = nil
+
+        nil
+    end
+
+
+end
+Error.unlazy_statics
+end # module Error
+end # module Quark
+end # module Quark

data/lib/quark/logging.rb

@@ -0,0 +1,278 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.logging; Logging; end
+module Logging
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+
+
+def self.Appender; Appender; end
+##
+# Destination for logging
+
+class Appender < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :name
+    extend ::DatawireQuarkCore::Static
+
+    static quark_logging_Appender_ref: -> { nil }
+
+
+
+    def initialize(name)
+        
+        self.__init_fields__
+        (self).name = name
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.logging.Appender"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("name"))
+            return (self).name
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("name"))
+            (self).name = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.name = nil
+
+        nil
+    end
+
+
+end
+Appender.unlazy_statics
+
+##
+# Logging appender that sends log messages to standard output
+
+def self.stdout()
+    
+    return ::Quark.quark.logging.Appender.new(":STDOUT")
+
+
+    nil
+end
+
+##
+# Logging appender that sends log messages to standard error
+
+def self.stderr()
+    
+    return ::Quark.quark.logging.Appender.new(":STDERR")
+
+
+    nil
+end
+
+##
+# Logging appender that sends log messages to a file
+
+def self.file(path)
+    
+    return ::Quark.quark.logging.Appender.new(path)
+
+
+    nil
+end
+
+##
+# Set an environment variable to override logging set up in the code
+
+def self.setEnvironmentOverride(envVar, level)
+    
+    ::Quark.quark.logging.Config._overrideEnvVar = envVar
+    ::Quark.quark.logging.Config._overrideLevel = level
+
+
+    nil
+end
+
+def self.Config; Config; end
+##
+# Logging configurator
+
+class Config < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :appender, :level
+    extend ::DatawireQuarkCore::Static
+
+    static _overrideEnvVar: -> { "QUARK_TRACE" }
+    static _overrideLevel: -> { "DEBUG" }
+    static _configured: -> { false }
+    static quark_logging_Config_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Set the destination for logging, default stderr()
+
+    def setAppender(appender)
+        
+        (self).appender = appender
+        return self
+
+        nil
+    end
+
+    ##
+    # set the logging level [trace|debug|info|warn|error], default 'info'
+
+    def setLevel(level)
+        
+        (self).level = level
+        return self
+
+        nil
+    end
+
+    def self._getOverrideIfExists()
+        
+        if ((::Quark.quark.logging.Config._overrideEnvVar) == (nil))
+            return ::DatawireQuarkCore.cast(nil) { ::String }
+        end
+        envVarValue = ENV[::Quark.quark.logging.Config._overrideEnvVar]
+        if (((((envVarValue) == (nil)) || ((envVarValue) == (""))) || ((envVarValue) == ("0"))) || (((envVarValue).downcase) == ("false")))
+            return ::DatawireQuarkCore.cast(nil) { ::String }
+        end
+        return envVarValue
+
+        nil
+    end
+
+    def self._autoconfig()
+        
+        return (!(::Quark.quark.logging.Config._configured)) && ((::Quark.quark.logging.Config._getOverrideIfExists()) != (nil))
+
+        nil
+    end
+
+    ##
+    # Configure the logging
+
+    def configure()
+        
+        envVarValue = ::Quark.quark.logging.Config._getOverrideIfExists()
+        if ((envVarValue) != (nil))
+            if (((envVarValue) == ("1")) || (((envVarValue).downcase) == ("true")))
+                @appender = ::Quark.quark.logging.stderr()
+            else
+                @appender = ::Quark.quark.logging.file(envVarValue)
+            end
+            @level = ::Quark.quark.logging.Config._overrideLevel
+        end
+        ::DatawireQuarkCore.configureLogging((@appender), (@level))
+        ::Quark.quark.logging.Config._configured = true
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.logging.Config"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_overrideEnvVar"))
+            return ::Quark.quark.logging.Config._overrideEnvVar
+        end
+        if ((name) == ("_overrideLevel"))
+            return ::Quark.quark.logging.Config._overrideLevel
+        end
+        if ((name) == ("_configured"))
+            return ::Quark.quark.logging.Config._configured
+        end
+        if ((name) == ("appender"))
+            return (self).appender
+        end
+        if ((name) == ("level"))
+            return (self).level
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_overrideEnvVar"))
+            ::Quark.quark.logging.Config._overrideEnvVar = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("_overrideLevel"))
+            ::Quark.quark.logging.Config._overrideLevel = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("_configured"))
+            ::Quark.quark.logging.Config._configured = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("appender"))
+            (self).appender = ::DatawireQuarkCore.cast(value) { ::Quark.quark.logging.Appender }
+        end
+        if ((name) == ("level"))
+            (self).level = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.appender = ::Quark.quark.logging.stderr()
+        self.level = "INFO"
+
+        nil
+    end
+
+
+end
+Config.unlazy_statics
+
+##
+# Create a logging configurator
+
+def self.makeConfig()
+    
+    return ::Quark.quark.logging.Config.new()
+
+
+    nil
+end
+end # module Logging
+end # module Quark
+end # module Quark

data/lib/quark/mock.rb

@@ -0,0 +1,1223 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.mock; Mock; end
+module Mock
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+require_relative '../quark' # 0 () ('quark',)
+require_relative 'concurrent' # 1 () ()
+require_relative 'test' # 1 () ()
+
+
+def self.MockEvent; MockEvent; end
+class MockEvent < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_MockEvent_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getType()
+        raise NotImplementedError, '`MockEvent.getType` is an abstract method'
+
+        nil
+    end
+
+    def getArgs()
+        raise NotImplementedError, '`MockEvent.getArgs` is an abstract method'
+
+        nil
+    end
+
+    def toString()
+        
+        return (self.getType()) + ((self.getArgs()).to_s)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.MockEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+MockEvent.unlazy_statics
+
+def self.SocketEvent; SocketEvent; end
+class SocketEvent < ::Quark.quark.mock.MockEvent
+    attr_accessor :url, :handler, :sock, :expectIdx
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_SocketEvent_ref: -> { nil }
+
+
+
+    def initialize(url, handler)
+        
+        super()
+        (self).url = url
+        (self).handler = handler
+
+        nil
+    end
+
+
+
+
+    def getType()
+        
+        return "socket"
+
+        nil
+    end
+
+    def getArgs()
+        
+        return ::DatawireQuarkCore::List.new([@url, @handler])
+
+        nil
+    end
+
+    def accept()
+        
+        if ((@sock) != (nil))
+            ::Quark.quark.concurrent.Context.runtime().fail("already accepted")
+        else
+            @sock = ::Quark.quark.mock.MockSocket.new(@handler)
+        end
+
+        nil
+    end
+
+    def send(message)
+        
+        @handler.onWSMessage(@sock, message)
+
+        nil
+    end
+
+    def close()
+        
+        (self).sock.close()
+
+        nil
+    end
+
+    def expectMessage()
+        
+        if ((@sock) == (nil))
+            ::Quark.quark.concurrent.Context.runtime().fail("not accepted")
+        end
+        if (::Quark.quark.test.check((@expectIdx) < (((@sock).messages).size), "expected a message"))
+            msg = ((@sock).messages)[@expectIdx]
+            @expectIdx = (@expectIdx) + (1)
+            return msg
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.MockMessage }
+
+        nil
+    end
+
+    def expectTextMessage()
+        
+        msg = self.expectMessage()
+        if (((msg) != (nil)) && (msg.isText()))
+            return ::DatawireQuarkCore.cast(msg) { ::Quark.quark.mock.TextMessage }
+        else
+            return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.TextMessage }
+        end
+
+        nil
+    end
+
+    def expectBinaryMessage()
+        
+        msg = self.expectMessage()
+        if (((msg) != (nil)) && (msg.isBinary()))
+            return ::DatawireQuarkCore.cast(msg) { ::Quark.quark.mock.BinaryMessage }
+        else
+            return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.BinaryMessage }
+        end
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.SocketEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("url"))
+            return (self).url
+        end
+        if ((name) == ("handler"))
+            return (self).handler
+        end
+        if ((name) == ("sock"))
+            return (self).sock
+        end
+        if ((name) == ("expectIdx"))
+            return (self).expectIdx
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("url"))
+            (self).url = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("handler"))
+            (self).handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.WSHandler }
+        end
+        if ((name) == ("sock"))
+            (self).sock = ::DatawireQuarkCore.cast(value) { ::Quark.quark.mock.MockSocket }
+        end
+        if ((name) == ("expectIdx"))
+            (self).expectIdx = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.url = nil
+        self.handler = nil
+        self.sock = nil
+        self.expectIdx = 0
+
+        nil
+    end
+
+
+end
+SocketEvent.unlazy_statics
+
+def self.MockMessage; MockMessage; end
+class MockMessage < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_MockMessage_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def isBinary()
+        
+        return !(self.isText())
+
+        nil
+    end
+
+    def isText()
+        raise NotImplementedError, '`MockMessage.isText` is an abstract method'
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.MockMessage"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        nil
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+MockMessage.unlazy_statics
+
+def self.TextMessage; TextMessage; end
+##
+# A text message.
+
+class TextMessage < ::Quark.quark.mock.MockMessage
+    attr_accessor :text
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_TextMessage_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super()
+        @text = message
+
+        nil
+    end
+
+
+
+
+    def isText()
+        
+        return true
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.TextMessage"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("text"))
+            return (self).text
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("text"))
+            (self).text = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.text = nil
+
+        nil
+    end
+
+
+end
+TextMessage.unlazy_statics
+
+def self.BinaryMessage; BinaryMessage; end
+##
+# A binary message.
+
+class BinaryMessage < ::Quark.quark.mock.MockMessage
+    attr_accessor :bytes
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_BinaryMessage_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super()
+        @bytes = message
+
+        nil
+    end
+
+
+
+
+    def isText()
+        
+        return false
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.BinaryMessage"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("bytes"))
+            return (self).bytes
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("bytes"))
+            (self).bytes = value
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.bytes = nil
+
+        nil
+    end
+
+
+end
+BinaryMessage.unlazy_statics
+
+def self.MockSocket; MockSocket; end
+class MockSocket < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :messages, :closed, :handler
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark_mock_MockMessage__ref: -> { nil }
+    static quark_mock_MockSocket_ref: -> { nil }
+
+
+
+    def initialize(handler)
+        
+        self.__init_fields__
+        (self).handler = handler
+        (self).closed = false
+        (self).messages = ::DatawireQuarkCore::List.new([])
+        handler.onWSInit(self)
+        handler.onWSConnected(self)
+
+        nil
+    end
+
+
+
+
+    def send(message)
+        
+        (@messages) << (::Quark.quark.mock.TextMessage.new(message))
+        return true
+
+        nil
+    end
+
+    def sendBinary(bytes)
+        
+        (@messages) << (::Quark.quark.mock.BinaryMessage.new(bytes))
+        return true
+
+        nil
+    end
+
+    def close()
+        
+        if (@closed)
+            ::Quark.quark.concurrent.Context.runtime().fail("already closed")
+        else
+            @handler.onWSClosed(self)
+            @handler.onWSFinal(self)
+            @closed = true
+        end
+        return true
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.MockSocket"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("messages"))
+            return (self).messages
+        end
+        if ((name) == ("closed"))
+            return (self).closed
+        end
+        if ((name) == ("handler"))
+            return (self).handler
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("messages"))
+            (self).messages = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("closed"))
+            (self).closed = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("handler"))
+            (self).handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.WSHandler }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.messages = ::DatawireQuarkCore::List.new([])
+        self.closed = false
+        self.handler = nil
+
+        nil
+    end
+
+
+end
+MockSocket.unlazy_statics
+
+def self.RequestEvent; RequestEvent; end
+class RequestEvent < ::Quark.quark.mock.MockEvent
+    attr_accessor :request, :handler
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_RequestEvent_ref: -> { nil }
+
+
+
+    def initialize(request, handler)
+        
+        super()
+        (self).request = request
+        (self).handler = handler
+
+        nil
+    end
+
+
+
+
+    def getType()
+        
+        return "request"
+
+        nil
+    end
+
+    def getArgs()
+        
+        return ::DatawireQuarkCore::List.new([@request, @handler])
+
+        nil
+    end
+
+    def respond(code, headers, body)
+        
+        response = ::Quark.quark.mock.MockResponse.new()
+        (response).code = code
+        (response).headers = headers
+        (response).body = body
+        @handler.onHTTPInit(@request)
+        @handler.onHTTPResponse(@request, response)
+        @handler.onHTTPFinal(@request)
+
+        nil
+    end
+
+    def fail(error)
+        
+        @handler.onHTTPInit(@request)
+        @handler.onHTTPError(@request, error)
+        @handler.onHTTPFinal(@request)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.RequestEvent"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("request"))
+            return (self).request
+        end
+        if ((name) == ("handler"))
+            return (self).handler
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("request"))
+            (self).request = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPRequest }
+        end
+        if ((name) == ("handler"))
+            (self).handler = ::DatawireQuarkCore.cast(value) { ::Quark.quark.HTTPHandler }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.request = nil
+        self.handler = nil
+
+        nil
+    end
+
+
+end
+RequestEvent.unlazy_statics
+
+def self.MockResponse; MockResponse; end
+class MockResponse < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :code, :body, :headers
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_MockResponse_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def getCode()
+        
+        return @code
+
+        nil
+    end
+
+    def setCode(code)
+        
+        (self).code = code
+
+        nil
+    end
+
+    def getBody()
+        
+        return @body
+
+        nil
+    end
+
+    def setBody(body)
+        
+        (self).body = body
+
+        nil
+    end
+
+    def setHeader(key, value)
+        
+        (@headers)[key] = (value)
+
+        nil
+    end
+
+    def getHeader(key)
+        
+        return (@headers)[key]
+
+        nil
+    end
+
+    def getHeaders()
+        
+        return ::DatawireQuarkCore::List.new((@headers).keys)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.MockResponse"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("code"))
+            return (self).code
+        end
+        if ((name) == ("body"))
+            return (self).body
+        end
+        if ((name) == ("headers"))
+            return (self).headers
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("code"))
+            (self).code = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("body"))
+            (self).body = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("headers"))
+            (self).headers = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.code = nil
+        self.body = nil
+        self.headers = {}
+
+        nil
+    end
+
+
+end
+MockResponse.unlazy_statics
+
+def self.MockTask; MockTask; end
+class MockTask < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :task, :delay, :_scheduledFor
+    extend ::DatawireQuarkCore::Static
+
+    static quark_mock_MockTask_ref: -> { nil }
+
+
+
+    def initialize(task, delay)
+        
+        self.__init_fields__
+        (self).task = task
+        (self).delay = delay
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.mock.MockTask"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("task"))
+            return (self).task
+        end
+        if ((name) == ("delay"))
+            return (self).delay
+        end
+        if ((name) == ("_scheduledFor"))
+            return (self)._scheduledFor
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("task"))
+            (self).task = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Task }
+        end
+        if ((name) == ("delay"))
+            (self).delay = ::DatawireQuarkCore.cast(value) { ::Float }
+        end
+        if ((name) == ("_scheduledFor"))
+            (self)._scheduledFor = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.task = nil
+        self.delay = nil
+        self._scheduledFor = nil
+
+        nil
+    end
+
+
+end
+MockTask.unlazy_statics
+
+def self.MockRuntime; MockRuntime; end
+class MockRuntime < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :runtime, :events, :tasks, :_executed_tasks, :executed, :_currentTime
+    extend ::DatawireQuarkCore::Static
+
+    static quark_List_quark_mock_MockEvent__ref: -> { nil }
+    static quark_List_quark_mock_MockTask__ref: -> { nil }
+    static quark_List_quark_bool__ref: -> { nil }
+    static quark_mock_MockRuntime_ref: -> { nil }
+
+
+
+    def initialize(runtime)
+        
+        self.__init_fields__
+        (self).runtime = runtime
+
+        nil
+    end
+
+
+
+
+    ##
+    # Execute all currently scheduled tasks.
+
+    def pump()
+        
+        size = (@tasks).size
+        idx = 0
+        while ((idx) < (size)) do
+            if ((@_executed_tasks)[idx])
+                idx = (idx) + (1)
+                next
+            end
+            wrapper = (@tasks)[idx]
+            next_ = ((@tasks)[idx]).task
+            if (((wrapper)._scheduledFor) <= (self.now()))
+                (@_executed_tasks)[idx] = (true)
+                next_.onExecute(self)
+                @executed = (@executed) + (1)
+            end
+            idx = (idx) + (1)
+        end
+
+        nil
+    end
+
+    def open(url, handler)
+        
+        (@events) << (::Quark.quark.mock.SocketEvent.new(url, handler))
+
+        nil
+    end
+
+    def request(request, handler)
+        
+        (@events) << (::Quark.quark.mock.RequestEvent.new(request, handler))
+
+        nil
+    end
+
+    def schedule(handler, delayInSeconds)
+        
+        task = ::Quark.quark.mock.MockTask.new(handler, delayInSeconds)
+        (task)._scheduledFor = (self.now()) + (((1000.0) * (delayInSeconds)).round())
+        (@tasks) << (task)
+        (@_executed_tasks) << (false)
+
+        nil
+    end
+
+    def codec()
+        
+        return @runtime.codec()
+
+        nil
+    end
+
+    def now()
+        
+        return @_currentTime
+
+        nil
+    end
+
+    def advanceClock(ms)
+        
+        @_currentTime = (@_currentTime) + (ms)
+
+        nil
+    end
+
+    def sleep(seconds)
+        
+        @runtime.sleep(seconds)
+
+        nil
+    end
+
+    def uuid()
+        
+        return @runtime.uuid()
+
+        nil
+    end
+
+    def serveHTTP(url, servlet)
+        
+        @runtime.fail("Runtime.serveHTTP not yet supported by the MockRuntime")
+
+        nil
+    end
+
+    def serveWS(url, servlet)
+        
+        @runtime.fail("Runtime.serveWS not yet supported by the MockRuntime")
+
+        nil
+    end
+
+    def respond(request, response)
+        
+        @runtime.fail("Runtime.respond not yet supported by the MockRuntime")
+
+        nil
+    end
+
+    def fail(message)
+        
+        @runtime.fail(message)
+
+        nil
+    end
+
+    def logger(topic)
+        
+        return @runtime.logger(topic)
+
+        nil
+    end
+
+    def callSafely(callee, defaultResult)
+        
+        return (callee).call(nil)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.MockRuntime"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("runtime"))
+            return (self).runtime
+        end
+        if ((name) == ("events"))
+            return (self).events
+        end
+        if ((name) == ("tasks"))
+            return (self).tasks
+        end
+        if ((name) == ("_executed_tasks"))
+            return (self)._executed_tasks
+        end
+        if ((name) == ("executed"))
+            return (self).executed
+        end
+        if ((name) == ("_currentTime"))
+            return (self)._currentTime
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("runtime"))
+            (self).runtime = ::DatawireQuarkCore.cast(value) { ::Quark.quark.Runtime }
+        end
+        if ((name) == ("events"))
+            (self).events = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("tasks"))
+            (self).tasks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_executed_tasks"))
+            (self)._executed_tasks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("executed"))
+            (self).executed = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("_currentTime"))
+            (self)._currentTime = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.runtime = nil
+        self.events = ::DatawireQuarkCore::List.new([])
+        self.tasks = ::DatawireQuarkCore::List.new([])
+        self._executed_tasks = ::DatawireQuarkCore::List.new([])
+        self.executed = 0
+        self._currentTime = 1000000
+
+        nil
+    end
+
+
+end
+MockRuntime.unlazy_statics
+
+def self.MockRuntimeTest; MockRuntimeTest; end
+class MockRuntimeTest < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :mock, :old, :expectIdx, :sockets
+    extend ::DatawireQuarkCore::Static
+
+    static quark_Map_quark_String_quark_mock_SocketEvent__ref: -> { nil }
+    static quark_mock_MockRuntimeTest_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    def setup()
+        
+        @old = ::Quark.quark.concurrent.Context.current()
+        ctx = ::Quark.quark.concurrent.Context.new(::Quark.quark.concurrent.Context.current())
+        @mock = ::Quark.quark.mock.MockRuntime.new((ctx)._runtime)
+        (ctx)._runtime = @mock
+        ::Quark.quark.concurrent.Context.swap(ctx)
+        @expectIdx = 0
+        @sockets = {}
+
+        nil
+    end
+
+    def teardown()
+        
+        ::Quark.quark.concurrent.Context.swap(@old)
+
+        nil
+    end
+
+    ##
+    # Execute any pending asynchronous tasks.
+
+    def pump()
+        
+        @mock.pump()
+
+        nil
+    end
+
+    def expectNone()
+        
+        delta = (((@mock).events).size) - (@expectIdx)
+        ::Quark.quark.test.check((delta) == (0), ("expected no events, got ") + ((delta).to_s))
+        return delta
+
+        nil
+    end
+
+    def expectEvent(expectedType)
+        
+        result = ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.MockEvent }
+        if (::Quark.quark.test.check((((@mock).events).size) > (@expectIdx), (("expected ") + (expectedType)) + (" event, got no events")))
+            type = ((@mock).events)[@expectIdx].getType()
+            if (::Quark.quark.test.check((type) == (expectedType), ((("expected ") + (expectedType)) + (" event, got ")) + (type)))
+                result = ((@mock).events)[@expectIdx]
+            end
+        end
+        @expectIdx = (@expectIdx) + (1)
+        return result
+
+        nil
+    end
+
+    def expectRequest(expectedUrl)
+        
+        rev = ::DatawireQuarkCore.cast(self.expectEvent("request")) { ::Quark.quark.mock.RequestEvent }
+        if ((rev) != (nil))
+            if ((expectedUrl) == (nil))
+                return rev
+            end
+            url = (rev).request.getUrl()
+            if (::Quark.quark.test.check((url) == (expectedUrl), (((("expected request event to url(") + (expectedUrl)) + ("), got url(")) + (url)) + (")")))
+                return rev
+            end
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.RequestEvent }
+
+        nil
+    end
+
+    def expectSocket(expectedUrl)
+        
+        sev = ::DatawireQuarkCore.cast(self.expectEvent("socket")) { ::Quark.quark.mock.SocketEvent }
+        if ((sev) != (nil))
+            (@sockets)[(sev).url] = (sev)
+            if ((expectedUrl) == (nil))
+                return sev
+            end
+            url = (sev).url
+            if (::Quark.quark.test.check((url) == (expectedUrl), (((("expected socket event to url(") + (expectedUrl)) + ("), got url(")) + (url)) + (")")))
+                return sev
+            end
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.mock.SocketEvent }
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.mock.MockRuntimeTest"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("mock"))
+            return (self).mock
+        end
+        if ((name) == ("old"))
+            return (self).old
+        end
+        if ((name) == ("expectIdx"))
+            return (self).expectIdx
+        end
+        if ((name) == ("sockets"))
+            return (self).sockets
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("mock"))
+            (self).mock = ::DatawireQuarkCore.cast(value) { ::Quark.quark.mock.MockRuntime }
+        end
+        if ((name) == ("old"))
+            (self).old = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("expectIdx"))
+            (self).expectIdx = ::DatawireQuarkCore.cast(value) { ::Integer }
+        end
+        if ((name) == ("sockets"))
+            (self).sockets = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.mock = nil
+        self.old = nil
+        self.expectIdx = 0
+        self.sockets = nil
+
+        nil
+    end
+
+
+end
+MockRuntimeTest.unlazy_statics
+end # module Mock
+end # module Quark
+end # module Quark