Added os Wrapper

Author: ChristophLHR

README.md

@@ -7,6 +7,7 @@ This emulates the basic ccTweaked functions missing in basic-lua.
 - vector-functions
 - settings
   - (no validations what so ever as of yet)
+- os.pullEvent etc.
 
 Additionally it emulates our **[scm](https://github.com/mc-cc-scripts/script-manager)** script and includes the **[json](https://gist.github.com/tylerneylon/59f4bcf316be525b30ab)** handler - which makes tests a lot easier.
 
@@ -34,6 +35,10 @@ local scriptToTest = require("scriptToTest")
 -- without any need to modify the script you want to test
 ```
 
+#### os
+[how to test with os functions](docs/ccOS.md)
+
+
 ### How to import these scripts
 
 For how to import the scipts, an example is already used by this repo for some of ITS dependancies (which you will also need):

events.lua renamed to ccOS.lua

@@ -18,17 +18,17 @@ local class = require("ccClass")
 ---@field thread thread
 ---@field waiting boolean
 
----@class ccEvent
+---@class ccOS
 ---@field FIFOEventList Event[]
 ---@field TimerList timerList
 ---@field thread thread
 ---@field subThreads table<string, subThread>
 ---@field time number eq. os.time("ingame") from ccTweaked)
 ---@field epoch number eq. os.epoch("ingame") from ccTweaked)
 ---@field private run thread
-local Events = class(
+local ccOS = class(
     function(baseClass)
-        ---@cast baseClass ccEvent
+        ---@cast baseClass ccOS
         baseClass.FIFOEventList = {}
         baseClass.TimerList = {timers = {}, currentID = 1}
         baseClass.time = 0
@@ -65,9 +65,9 @@ local Events = class(
 ---@param wrapModule? boolean This will modify the Module!
 ---@param ... any If loading a Module, these are the parameters
 ---@return T|nil result if module is wrapped, it returns the wrapped module. 
-function Events:wrap(func, wrapModule, ...)
+function ccOS:wrap(func, wrapModule, ...)
     assert(self.subThreads, "Do not use Eventclass, create an Event-Object via 'local eventObj = ccEvent()'")
-    local manager = self
+    local ccOSInstance = self
     local env = {}
         ---@class EventOS: oslib
     env.os = setmetatable({
@@ -82,15 +82,31 @@ function Events:wrap(func, wrapModule, ...)
             return table.unpack(event)
         end,
         queueEvent = function(name, ...)
-            manager:invoke(name, ...)
+            ccOSInstance:invoke(name, ...)
         end,
         startTimer = function(time)
             assert(type(time) == "number")
-            return manager:addTimer(time)
+            return ccOSInstance:addTimer(time)
         end,
         cancleTimer = function(id)
-            manager:removeTimer(id)
-        end
+            ccOSInstance:removeTimer(id)
+        end,
+        sleep = function(time)
+            local expectedId = env.os.startTimer(time)
+            local correctTimer = false
+            while not correctTimer do
+                local _, id = env.os.pullEvent("timer")
+                correctTimer = id == expectedId
+            end
+        end,
+        time = function()
+            -- TODO: add locale
+            return ccOSInstance.time
+        end,
+        epoch = function()
+            -- TODO: add args
+            return ccOSInstance.epoch
+        end,
 
     }, {__index = os})
     setmetatable(env, {__index = _G})
@@ -140,7 +156,7 @@ end
 
 ---@param time number seconds
 ---@return number timerID
-function Events:addTimer(time)
+function ccOS:addTimer(time)
     assert(type(time) == "number" and time > 0)
     local triggerAfter = time * 1000 + self.epoch - 1
     local id = self.TimerList.currentID
@@ -149,19 +165,19 @@ function Events:addTimer(time)
     return id
 end
 
-function Events:removeTimer(id)
+function ccOS:removeTimer(id)
     assert(type(id) == "number")
     for k,v in pairs(self.TimerList.timers) do
         if v.id == id then
-            self.TimerList.currentID[id] = nil
+            self.TimerList.timers[id] = nil
         end
     end
 end
 
 ---Passes time (in Seconds)
 ---Required for timers
 ---@param time number seconds
-function Events:passTime(time)
+function ccOS:passTime(time)
     assert(type(time) == "number")
     time = time * 1000
     self.time = (self.time + (time / 60 / 24)) % 24 -- TODO: Test
@@ -176,12 +192,12 @@ function Events:passTime(time)
 
 end
 
-function Events:invoke(eventName, ...)
+function ccOS:invoke(eventName, ...)
     ---@type Event
     local event = {eventName = eventName, receivedBy = {}, eventArgs = {...}}
     table.insert(self.FIFOEventList, event)
     self.newEventAdded = true
     assert(coroutine.resume(self.run, "tick"))
 end
 
-return Events
+return ccOS

docs/ccOS.md

@@ -0,0 +1,36 @@
+# OS
+
+## How to use
+
+### for functions
+```lua
+-- import 
+local osEmulator = require("ccOS")
+
+-- create instance
+local osInstance = osEmulator()
+
+local testFunction = osInstance:wrap(function()
+    os.pullEvent("CustomEvent")
+    print("Event got called")
+end)
+
+testFunction() -- < Programm yields until event gets invoked, in the instances' thread
+osInstance:invoke("CustomEvent") -- < Programm continues -> prints: "Event got called"
+
+```
+
+### for Modules
+```lua
+local osEmulator = require("ccOS")
+-- create instance
+local osInstance = osEmulator()
+
+local moduleFile = loadfile("someModule","t")
+local testModule = osInstance:wrap(moduleFile, true, ...)
+-- <true> tells the wrapper to wrap all functioncalls, so they run in a coroutine thread, instead of the callers thread
+-- <...> as the module will need to be called once, you can provide additional parameters as need
+
+testModule:someFunction(...)
+-- the function will now run on the osInstance-Thread, knowing all currently implemented os-Functions
+```

tests/event_spec.lua

@@ -0,0 +1,118 @@
+---@class are
+---@field same string
+---@field equal string
+---@field equals string
+
+---@class is
+---@field truthy string
+---@field falsy string
+---@field not_true string
+---@field not_false string
+
+---@class has
+---@field error string
+---@field errors string
+
+---@class assert
+---@field are are
+---@field is is
+---@field are_not are
+---@field is_not is
+---@field has has
+---@field has_no has
+---@field True string
+---@field False string
+---@field has_error string
+---@field is_false string
+---@field is_true string
+---@field equal string
+assert = assert
+
+package.path = package.path .. ";"
+    .."libs/?.lua;"
+
+local osEmulator = require("ccOS")
+
+describe("Event-Tests", function ()
+    ---@type ccOS, TestFile, string
+    local osEnv, testModule, invokeWord
+    local path = "tests/testFiles/event_testFile.lua"
+    before_each(function()
+        osEnv = osEmulator()
+    end)
+    describe("#basics", function()
+        it("#pullAndInvokeOnFunctionOnly", function ()
+            invokeWord = "testEvent"
+            local testFunc = osEnv:wrap(function(parameter)
+                assert(parameter == "parameterCheck")
+                os.pullEvent(invokeWord)
+            end, false)
+            
+            testFunc("parameterCheck")
+            assert.are.equal("suspended", coroutine.status(osEnv.thread))
+            osEnv:invoke()
+            assert.are.equal("suspended", coroutine.status(osEnv.thread))
+            osEnv:invoke(invokeWord)
+            assert.are.equal("dead", coroutine.status(osEnv.thread))
+        end)
+        it("#pullAndInvokeModule", function()
+            local file = loadfile(path, "t")
+            testModule = osEnv:wrap(file, true)
+            assert(type(testModule)=="table", type(testModule))
+
+            invokeWord = "test"
+            assert.are.equal(false, osEnv.subThreads.event1.waiting)
+            testModule:event1(invokeWord) -- start function (runs in a thread)
+            assert.are.equal(true, osEnv.subThreads.event1.waiting)
+            osEnv:invoke("wrongword")
+            assert.are.equal("suspended", coroutine.status(osEnv.subThreads.event1.thread))
+            osEnv:invoke(invokeWord)
+            assert.are.equal(false, osEnv.subThreads.event1.waiting)
+            assert.are.equal(invokeWord, testModule.status.event1)
+        end)
+    end)
+    describe("#timer",function()
+        it("#start", function()
+            local file = loadfile(path, "t")
+            testModule = osEnv:wrap(file, true)
+            assert(testModule)
+
+            testModule:event2()
+            testModule:event2()
+            testModule:event2()
+            assert.are.same(1, #osEnv.TimerList.timers) -- only one timer is inserted, the pullEvent didn't trigger
+            
+            assert.are.same(1, testModule.status.event2)
+            osEnv:passTime(3)
+            assert.are.same(1, testModule.status.event2)
+            osEnv:passTime(1)
+            assert.are.same(1, testModule.status.event2)
+            osEnv:passTime(1)
+            assert.are.same(nil, testModule.status.event2)
+            osEnv:passTime(1)
+            assert.are.same(nil, testModule.status.event2) -- the next pullEvent should never be triggered
+        end)
+        it("#cancel", function()
+            local file = loadfile(path, "t")
+            testModule = osEnv:wrap(file, true)
+            assert(testModule)
+
+            testModule:event2()
+            osEnv:removeTimer(1)
+            osEnv:passTime(8)
+            assert.are.same(1, testModule.status.event2)
+        end)
+        it("#sleep", function()
+            local file = loadfile(path, "t")
+            testModule = osEnv:wrap(file,true)
+            assert(testModule)
+
+            testModule:event3()
+            assert.are.same(nil, testModule.status.event3)
+            osEnv:passTime(4)
+            assert.are.same(nil, testModule.status.event3)
+            osEnv:passTime(1)
+            assert.are.same(true, testModule.status.event3)
+        end)
+    end)
+end)