RemoteTestResultSender.cs
4.33 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework.Interfaces;
using UnityEngine.Networking.PlayerConnection;
using UnityEngine.TestRunner.TestLaunchers;
namespace UnityEngine.TestTools.TestRunner.Callbacks
{
[AddComponentMenu("")]
internal class RemoteTestResultSender : MonoBehaviour, ITestRunnerListener
{
private class QueueData
{
public Guid id { get; set; }
public byte[] data { get; set; }
}
private const int k_aliveMessageFrequency = 120;
private float m_NextliveMessage = k_aliveMessageFrequency;
private readonly Queue<QueueData> m_SendQueue = new Queue<QueueData>();
private readonly object m_LockQueue = new object();
private readonly IRemoteTestResultDataFactory m_TestResultDataFactory = new RemoteTestResultDataFactory();
public void Start()
{
StartCoroutine(SendDataRoutine());
}
private byte[] SerializeObject(object objectToSerialize)
{
return Encoding.UTF8.GetBytes(JsonUtility.ToJson(objectToSerialize));
}
public void RunStarted(ITest testsToRun)
{
var data = SerializeObject(m_TestResultDataFactory.CreateFromTest(testsToRun));
lock (m_LockQueue)
{
m_SendQueue.Enqueue(new QueueData
{
id = PlayerConnectionMessageIds.runStartedMessageId,
data = data
});
}
}
public void RunFinished(ITestResult testResults)
{
var data = SerializeObject(m_TestResultDataFactory.CreateFromTestResult(testResults));
lock (m_LockQueue)
{
m_SendQueue.Enqueue(new QueueData { id = PlayerConnectionMessageIds.runFinishedMessageId, data = data, });
}
}
public void TestStarted(ITest test)
{
var data = SerializeObject(m_TestResultDataFactory.CreateFromTest(test));
lock (m_LockQueue)
{
m_SendQueue.Enqueue(new QueueData
{
id = PlayerConnectionMessageIds.testStartedMessageId,
data = data
});
}
}
public void TestFinished(ITestResult result)
{
var testRunnerResultForApi = m_TestResultDataFactory.CreateFromTestResult(result);
var resultData = SerializeObject(testRunnerResultForApi);
lock (m_LockQueue)
{
m_SendQueue.Enqueue(new QueueData
{
id = PlayerConnectionMessageIds.testFinishedMessageId,
data = resultData,
});
}
}
public IEnumerator SendDataRoutine()
{
while (!PlayerConnection.instance.isConnected)
{
yield return new WaitForSeconds(1);
}
while (true)
{
lock (m_LockQueue)
{
if (PlayerConnection.instance.isConnected && m_SendQueue.Count > 0)
{
ResetNextPlayerAliveMessageTime();
var queueData = m_SendQueue.Dequeue();
PlayerConnection.instance.Send(queueData.id, queueData.data);
yield return null;
}
//This is needed so we dont stall the player totally
if (!m_SendQueue.Any())
{
SendAliveMessageIfNeeded();
yield return new WaitForSeconds(0.02f);
}
}
}
}
private void SendAliveMessageIfNeeded()
{
if (Time.timeSinceLevelLoad < m_NextliveMessage)
{
return;
}
Debug.Log("Sending player alive message back to editor.");
ResetNextPlayerAliveMessageTime();
PlayerConnection.instance.Send(PlayerConnectionMessageIds.playerAliveHeartbeat, new byte[0]);
}
private void ResetNextPlayerAliveMessageTime()
{
m_NextliveMessage = Time.timeSinceLevelLoad + k_aliveMessageFrequency;
}
}
}