func TestDelayedMessaging(t *testing.T) {
dispatcher := testDispatcher{EventDispatcher: &DelayDispatcher{BasicDispatcher: &BasicDispatcher{}}}
space := &testMsgSpace{EventDispatcher: &BasicDispatcher{}}
dispatcher.SetOwner(space)
// TODO: make this generic when Component is defined
dispatcher.EventDispatcher.(*DelayDispatcher).Init()
rcvr := testDispatcher{EventDispatcher: &BasicDispatcher{}}
rcvr.RegisterForEvent("event", dispatcher, func(e EventData) {
rcvr.MsgReceived = true
})
msg := testEventData{Data: 5}
dispatcher.TriggerEvent("event", &msg)
test.ExpectEQ(t, true, rcvr.MsgReceived, "message handler shouldn't have triggered")
rcvr.MsgReceived = false
var delay float32 = 100.0
msg.Delay = delay
dispatcher.TriggerEvent("event", &msg)
// No time passed
test.ExpectEQ(t, false, rcvr.MsgReceived, "message handler shouldn't have triggered")
// Too little time passed
var tooLittleDt float32 = 1
dtRemaining := delay - tooLittleDt
space.TriggerEvent("FrameUpdateEvent", &FrameUpdateEvent{tooLittleDt})
test.ExpectEQ(t, false, rcvr.MsgReceived, "message handler shouldn't have triggered")
// Enough time passed
enoughDt := dtRemaining
space.TriggerEvent("FrameUpdateEvent", &FrameUpdateEvent{enoughDt})
test.ExpectEQ(t, true, rcvr.MsgReceived, "message handler wasn't triggered")
}
func TestSerialize_Goc(t *testing.T) {
// test setup
CoreFactoryFunc = testFactoryFunc
data := []byte(
`{
"Type": "Goc",
"Name": "camera",
"Components": [
{
"Type": "CameraComponent",
"X": 100,
"Y": 50
},
{
"Type": "ColliderComponent",
"Shape": "aabb"
}
]
}`)
holder, _ := support.ReadData(data)
goc := Goc{}
SerializeInPlace(&goc, holder)
test.ExpectEQ(t, "camera", goc.Name, "goc.Name was set correctly")
cmp1 := goc.GetComp("serTestComp1").(*serTestComp1)
test.ExpectEQ(t, 100, cmp1.X, "cmp1.X was set correctly")
test.ExpectEQ(t, 50, cmp1.Y, "cmp1.Y was set correctly")
test.ExpectEQ(t, 0, cmp1.Z, "cmp1.Z was set correctly")
cmp2 := goc.GetComp("serTestComp2").(*serTestComp2)
test.ExpectEQ(t, "aabb", cmp2.Shape, "cmp2.Shape was set correctly")
}
func TestMessaging(t *testing.T) {
dispatcher := testDispatcher{EventDispatcher: &BasicDispatcher{}}
// test dispatching to one listenre
rcvr1 := testDispatcher{EventDispatcher: &BasicDispatcher{}}
rcvr1.RegisterForEvent("event1", dispatcher, func(e EventData) {
rcvr1.MsgData = e.(*testEventData).Data
})
msg := testEventData{Data: 5}
dispatcher.TriggerEvent("event1", &msg)
test.ExpectEQ(t, msg.Data, rcvr1.MsgData, "message handler wasn't triggered")
// dispatching to multiple listeners/events
rcvr2 := testDispatcher{EventDispatcher: &BasicDispatcher{}}
rcvr2.RegisterForEvent("event1", dispatcher, func(e EventData) {
rcvr2.MsgData = e.(*testEventData).Data
})
rcvr2.RegisterForEvent("event2", dispatcher, func(e EventData) {
rcvr2.OtherData = e.(*testEventData).Data
})
rcvr1.MsgData = 0
rcvr2.MsgData = 0
dispatcher.TriggerEvent("event1", &msg)
test.ExpectEQ(t, msg.Data, rcvr1.MsgData, "message handler wasn't triggered")
test.ExpectEQ(t, msg.Data, rcvr2.MsgData, "message handler wasn't triggered")
test.ExpectNEQ(t, msg.Data, rcvr2.OtherData, "message handler shouldn't have triggered")
dispatcher.TriggerEvent("event2", &msg)
test.ExpectEQ(t, msg.Data, rcvr2.OtherData, "message handler wasn't triggered")
}
func TestKernel_New(t *testing.T) {
core := New()
test.ExpectEQ(t, core.State, Running, "Core defaults to running.")
test.ExpectEQ(t, 0, core.CurrFrame, "Core starts on frame 0.")
// TODO: decide if I should test internals... hmmm
test.ExpectEQ(t, core.managers, []Manager(nil), "Core starts with no managers.")
}
func TestCore_Spaces(t *testing.T) {
core := New()
// Space Setup
Spc1 := &TestSpace{name: "Spc1"}
Spc2 := &TestSpace{name: "Spc2"}
core.RegisterSpace(Spc1)
core.RegisterSpace(Spc2)
// Testing core.StartUp()
actOut = nil
expOut := []string{
"Spc1 Init()",
"Spc2 Init()",
}
core.StartUp(nil)
test.AssertEQ(t, len(expOut), len(actOut), "Length of actOut and expOut aren't equal.")
for i, s := range actOut {
test.ExpectEQ(t, expOut[i], s, fmt.Sprintf("With test %d: Initialization order was wrong.", i))
}
// Testing Core.Run()
actOut = nil
expOut = []string{
"Spc1 Update()",
"Spc2 Update()",
}
core.State = Stopped
core.Run()
test.AssertEQ(t, len(expOut), len(actOut), "Length of actOut and expOut aren't equal.")
for i, s := range actOut {
test.ExpectEQ(t, expOut[i], s, fmt.Sprintf("With test %d: Frame Update order was wrong.", i))
}
// Testing core.ShutDown()
actOut = nil
expOut = []string{
"Spc2 DeInit()",
"Spc1 DeInit()",
}
core.ShutDown()
test.AssertEQ(t, len(expOut), len(actOut), "Length of actOut and expOut aren't equal.")
for i, s := range actOut {
test.ExpectEQ(t, expOut[i], s, fmt.Sprintf("With test %d: DeInitialization order was wrong.", i))
}
}
func TestCore_Run(t *testing.T) {
core := New()
core.State = Rebooting
test.ExpectEQ(t, utils.ES_Restart, core.Run(), "The core should have returned a restart value.")
test.ExpectEQ(t, 0, core.CurrFrame, "No frame ran.")
core.State = Terminated
test.ExpectEQ(t, utils.ES_Success, core.Run(), "The core should have return quit value.")
test.ExpectEQ(t, 0, core.CurrFrame, "No frame ran.")
core.State = Stopped
test.ExpectEQ(t, utils.ES_Success, core.Run(), "The core should return quit")
test.ExpectEQ(t, 1, core.CurrFrame, "One frame ran.")
core.RegisterManager(&frameControlMgr{core: core})
core.StartUp(nil)
core.State = Running
test.ExpectEQ(t, utils.ES_Success, core.Run(), "The core should return quit")
test.ExpectEQ(t, 5, core.CurrFrame, "Core ran until it was stopped.")
}
func TestDispatcherUnhooking(t *testing.T) {
dispatcher := testDispatcher{EventDispatcher: &BasicDispatcher{}}
// test dispatching to all listeners
rcvr1 := testDispatcher{EventDispatcher: &BasicDispatcher{}}
rcvr2 := testDispatcher{EventDispatcher: &BasicDispatcher{}}
rcvr3 := testDispatcher{EventDispatcher: &DelayDispatcher{BasicDispatcher: &BasicDispatcher{}}}
rcvr1.RegisterForEvent("event", dispatcher, func(e EventData) {
rcvr1.MsgReceived = true
})
rcvr2.RegisterForEvent("event", dispatcher, func(e EventData) {
rcvr2.MsgReceived = true
})
rcvr3.RegisterForEvent("event", dispatcher, func(e EventData) {
rcvr3.MsgReceived = true
})
dispatcher.TriggerEvent("event", nil)
test.ExpectEQ(t, true, rcvr1.MsgReceived, "message handler wasn't triggered - rcvr1 #1")
test.ExpectEQ(t, true, rcvr2.MsgReceived, "message handler wasn't triggered - rcvr2 #1")
test.ExpectEQ(t, true, rcvr3.MsgReceived, "message handler wasn't triggered - rcvr3 #1")
// TODO: make this generic when Component is defined
rcvr2.EventDispatcher.(*BasicDispatcher).DeInit()
rcvr1.MsgReceived, rcvr2.MsgReceived, rcvr3.MsgReceived = false, false, false
dispatcher.TriggerEvent("event", nil)
test.ExpectEQ(t, true, rcvr1.MsgReceived, "message handler wasn't triggered - rcvr1 #2")
test.ExpectEQ(t, false, rcvr2.MsgReceived, "message handler wasn't unhooked - rcvr2 #2")
test.ExpectEQ(t, true, rcvr3.MsgReceived, "message handler wasn't triggered - rcvr3 #2")
rcvr3.EventDispatcher.(*DelayDispatcher).DeInit()
rcvr1.MsgReceived, rcvr2.MsgReceived, rcvr3.MsgReceived = false, false, false
dispatcher.TriggerEvent("event", nil)
test.ExpectEQ(t, true, rcvr1.MsgReceived, "message handler wasn't triggered - rcvr1 #3")
test.ExpectEQ(t, false, rcvr2.MsgReceived, "message handler wasn't unhooked - rcvr2 #3")
test.ExpectEQ(t, false, rcvr3.MsgReceived, "message handler wasn't unhooked - rcvr3 #3")
rcvr1.EventDispatcher.(*BasicDispatcher).DeInit()
rcvr1.MsgReceived, rcvr2.MsgReceived, rcvr3.MsgReceived = false, false, false
dispatcher.TriggerEvent("event", nil)
test.ExpectEQ(t, false, rcvr1.MsgReceived, "message handler wasn't unhooked - rcvr1 #4")
test.ExpectEQ(t, false, rcvr2.MsgReceived, "message handler wasn't unhooked - rcvr2 #4")
test.ExpectEQ(t, false, rcvr3.MsgReceived, "message handler wasn't unhooked - rcvr3 #4")
rcvr1.RegisterForEvent("event", dispatcher, func(e EventData) {
rcvr1.MsgReceived = true
})
rcvr1.MsgReceived, rcvr2.MsgReceived, rcvr3.MsgReceived = false, false, false
dispatcher.TriggerEvent("event", nil)
test.ExpectEQ(t, true, rcvr1.MsgReceived, "message handler wasn't triggered - rcvr1 #5")
test.ExpectEQ(t, false, rcvr2.MsgReceived, "message handler wasn't unhooked - rcvr1 #5")
test.ExpectEQ(t, false, rcvr3.MsgReceived, "message handler wasn't unhooked - rcvr1 #5")
}
func TestKernelState(t *testing.T) {
test.ExpectEQ(t, "Kernel State: Stopped", Stopped.String(), "Stopped.String() failed.")
test.ExpectEQ(t, "Kernel State: Terminated", Terminated.String(), "Terminated.String() failed.")
test.ExpectEQ(t, "Kernel State: Rebooting", Rebooting.String(), "Rebooting.String() failed.")
test.ExpectEQ(t, "Kernel State: Running", Running.String(), "Running.String() failed.")
}
func TestCore_Managers(t *testing.T) {
core := New()
// Test Setup
Mgr1 := &TestManager{name: "Mgr1", comp: "TestMgr1InitComponent"}
Mgr2 := &TestManager{name: "Mgr2", comp: "TestMgr2InitComponent"}
CoreFactoryFunc = func(name string) interface{} {
var comp interface{}
switch name {
default:
support.LogFatal("unknown component: %s", name)
case "TestMgr1InitComponent":
comp = &TestMgr1InitComponent{}
case "TestMgr2InitComponent":
comp = &TestMgr2InitComponent{}
}
return comp
}
core.RegisterManager(Mgr1)
core.RegisterManager(Mgr2)
cfg := LoadConfig("C:/Users/jmorgan/Sandbox/golang/rsrc/test/json/objects/kernel/TestCore.jrm")
// Testing Core.StartUp()
actOut = nil
expOut := []string{
"Mgr1 StartUp()",
"Mgr1 got config",
"Mgr2 StartUp()",
"Mgr2 got config",
}
core.StartUp(cfg)
test.AssertEQ(t, len(expOut), len(actOut), "Length of actOut and expOut aren't equal. "+fmt.Sprintf("\n\t\tactOut: %v", actOut))
for i, s := range actOut {
test.ExpectEQ(t, expOut[i], s, fmt.Sprintf("With test %d: Initialization order was wrong.", i))
}
// Testing Core.Run()
actOut = nil
expOut = []string{
"Mgr1 BeginFrame()",
"Mgr2 BeginFrame()",
"Mgr2 EndFrame()",
"Mgr1 EndFrame()",
}
core.State = Stopped
core.Run()
test.AssertEQ(t, len(expOut), len(actOut), "Length of actOut and expOut aren't equal.")
for i, s := range actOut {
test.ExpectEQ(t, expOut[i], s, fmt.Sprintf("With test %d: Frame Update order was wrong.", i))
}
// Testing Core.ShutDown()
actOut = nil
expOut = []string{
"Mgr2 ShutDown()",
"Mgr1 ShutDown()",
}
core.ShutDown()
test.AssertEQ(t, len(expOut), len(actOut), "Length of actOut and expOut aren't equal.")
for i, s := range actOut {
test.ExpectEQ(t, expOut[i], s, fmt.Sprintf("With test %d: DeInitialization order was wrong.", i))
}
}