public void TestLoad()
{
var replaceList = new Dictionary <string, string>();
replaceList.Add("BOOTHID", "id");
replaceList.Add("NAME", "name");
Assert.That(TemplateLoader.Load("Sample_template", replaceList, "Assets"), Is.True);
AssetDatabase.CreateFolder("Assets", "TestTemplateLoad");
Assert.That(TemplateLoader.Load("Sample_template", replaceList, "Assets/TestTemplateLoad"), Is.True);
LogAssert.Expect(LogType.Error, new Regex("^Template load failed.*"));
TemplateLoader.Load("Sample_template", replaceList, "Assets/TestTemplateLoad/invalid");
LogAssert.Expect(LogType.Error, new Regex("^Template load failed.*"));
TemplateLoader.Load("Sample_template", replaceList, "invalid");
var invalidReplaceList = new Dictionary <string, string>();
invalidReplaceList.Add("BOOTHID", "/");
invalidReplaceList.Add("NAME", "test2");
AssetDatabase.CreateFolder("Assets", "TestTemplateLoad2");
LogAssert.Expect(LogType.Error, new Regex("^入力した文字列に使えない文字が含まれています。.*"));
TemplateLoader.Load("Sample_template", invalidReplaceList, "Assets/TestTemplateLoad2");
}
public void LogResult_SupportFormattingCharacters()
{
var pipeline = BuildPipeline.CreateInstance();
var config = BuildConfiguration.CreateInstance();
var resultSuccess = BuildPipelineResult.Success(pipeline, config);
Assert.DoesNotThrow(() =>
{
LogAssert.Expect(LogType.Log, new Regex(@"Build succeeded after .+\."));
resultSuccess.LogResult();
});
var resultFailure = BuildPipelineResult.Failure(pipeline, config, @"{}{{}}{0}{s}%s%%\s±@£¢¤¬¦²³¼½¾");
Assert.DoesNotThrow(() =>
{
LogAssert.Expect(LogType.Error, new Regex(@"Build failed after .+\.\n.+"));
resultFailure.LogResult();
});
}
public IEnumerator ImportAsync_ObjFetchSuccessMtlFetchFail_CreateObjectWithDefaultMat()
{
ObjImporter objImporter = SetUpObjImporter(cubeObj, "");
objImporter.MtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeFailLoader <string>();
LogAssert.Expect(LogType.Error, new Regex(@"\w*This is a simulated fail\w*"));
LogAssert.Expect(LogType.Error, new Regex(@"\w*Could not load .mtl file\w*"));
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
Assert.NotNull(res);
Assert.AreEqual(1, res.transform.childCount);
MeshRenderer mr = res.transform.GetChild(0).GetComponent <MeshRenderer>();
Assert.AreEqual("New Material", mr.sharedMaterial.name);
}
public IEnumerator UnloadingScene_Synchronously_LogsWarning()
{
var loadOp = m_Addressables.LoadSceneAsync(m_SceneKey, LoadSceneMode.Additive);
loadOp.WaitForCompletion();
yield return(loadOp);
var unloadOp = m_Addressables.UnloadSceneAsync(loadOp, UnloadSceneOptions.None, false);
LogAssert.Expect(LogType.Warning, "Cannot unload a Scene with WaitForCompletion. Scenes must be unloaded asynchronously.");
unloadOp.WaitForCompletion();
yield return(unloadOp);
Assert.AreEqual(AsyncOperationStatus.Succeeded, unloadOp.Status);
Assert.IsTrue(unloadOp.IsValid());
Assert.IsTrue(unloadOp.IsDone);
//Cleanup
ReleaseOp(unloadOp);
ReleaseOp(loadOp);
}
public void FindOrSpawnObject_ErrorWhenSpawnHanlderReturnsNull()
{
const uint netId = 1003;
SpawnMessage msg = new SpawnMessage
{
netId = netId,
assetId = validPrefabGuid
};
spawnHandlers.Add(validPrefabGuid, (x) =>
{
return(null);
});
LogAssert.Expect(LogType.Error, $"Spawn Handler returned null, Handler assetId '{msg.assetId}'");
LogAssert.Expect(LogType.Error, $"Could not spawn assetId={msg.assetId} scene={msg.sceneId} netId={msg.netId}");
bool success = ClientScene.FindOrSpawnObject(msg, out NetworkIdentity networkIdentity);
Assert.IsFalse(success);
Assert.IsNull(networkIdentity);
}
public void WhenAssetHasANullRepresentation_LogsWarning()
{
// Create an asset
string assetPath = Path.Combine(kTestAssetFolder, "myPrefab.prefab");
GUID guid = CreateGameObject(assetPath);
CalculateAssetDependencyData.TaskInput input = CreateDefaultInput();
input.Assets = new List <GUID>()
{
guid
};
input.EngineHooks = new NullLoadRepresentationFake();
LogAssert.Expect(LogType.Warning, new Regex(".+It will not be included in the build"));
CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output);
Assert.AreEqual(guid, output.AssetResults[0].asset);
Assert.AreEqual(2, output.AssetResults[0].assetInfo.includedObjects.Count); // GameObject and Transform
Assert.AreEqual(0, output.AssetResults[0].assetInfo.referencedObjects.Count);
}
public void NativeBitArray_CreateAndUseAfterFreeInBurstJob_UsesCustomOwnerTypeName()
{
// Make sure this isn't the first container of this type ever created, so that valid static safety data exists
var numBits = 256;
var test = new NativeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory);
test.Dispose();
var job = new NativeBitArrayCreateAndUseAfterFreeBurst
{
};
// Two things:
// 1. This exception is logged, not thrown; thus, we use LogAssert to detect it.
// 2. Calling write operation after container.Dispose() emits an unintuitive error message. For now, all this test cares about is whether it contains the
// expected type name.
job.Run();
LogAssert.Expect(LogType.Exception,
new Regex($"InvalidOperationException: The {Regex.Escape(test.GetType().ToString())} has been declared as \\[ReadOnly\\] in the job, but you are writing to it"));
}
public void SendCalledWhileNotActive_ShouldGiveWarning(string functionName)
{
LogAssert.Expect(LogType.Warning, $"Can not send using NetworkServer.{functionName}<T>(T msg) because NetworkServer is not active");
switch (functionName)
{
case nameof(NetworkServer.SendToAll):
NetworkServer.SendToAll(new NetworkPingMessage {
});
break;
case nameof(NetworkServer.SendToReady):
NetworkServer.SendToReady(new NetworkPingMessage {
});
break;
default:
Debug.LogError("Could not find function name");
break;
}
}
public IEnumerator EndTurnTest2()
{
Player previousPlayer = GameManager.CurrentPlayer;
GameManager.Players[1].IsHuman = true;
Assert.NotNull(previousPlayer);
foreach (Character character in previousPlayer.Characters)
{
character.HasMoved = true;
}
yield return(null);
LogAssert.Expect(LogType.Log, "All characters have moved");
Player currentPlayer = GameManager.CurrentPlayer;
Assert.NotNull(currentPlayer);
Assert.AreNotSame(previousPlayer, currentPlayer);
}
public IEnumerator SetupThrows_ShouldDisable()
{
ResetScene();
yield return(new EnterPlayMode());
var mockLabeler = new Mock <CameraLabeler>();
mockLabeler.Protected().Setup("Setup").Throws <InvalidOperationException>();
var labeler = mockLabeler.Object;
var camera = SetupCamera(null);
camera.GetComponent <PerceptionCamera>().AddLabeler(labeler);
LogAssert.Expect(LogType.Exception, "InvalidOperationException: Operation is not valid due to the current state of the object.");
yield return(null);
mockLabeler.Protected().Verify("Setup", Times.Once());
mockLabeler.Protected().Verify("OnUpdate", Times.Never());
mockLabeler.Protected().Verify("OnBeginRendering", Times.Never());
Assert.IsFalse(labeler.enabled);
yield return(new ExitPlayMode());
}
public void CreateBranchWithDuplicateChildren()
{
const int brushUserID = 10;
const int branchUserID = 12;
CSGTreeBrush brush = CSGTreeBrush.Create(userID: brushUserID);
CSGManager.ClearDirty(brush);
LogAssert.Expect(LogType.Error, new Regex("Have duplicate child"));
CSGTreeBranch branch = CSGTreeBranch.Create(branchUserID, new CSGTreeNode[] { brush, brush });
TestUtility.ExpectInvalidBranch(ref branch);
Assert.AreEqual(false, brush.Dirty);
Assert.AreEqual(0, brush.Parent.NodeID);
Assert.AreEqual(0, brush.Tree.NodeID);
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist");
Assert.AreEqual(1, CSGManager.TreeNodeCount, "Expected 1 TreeNode to Exist");
}
public void ShouldLogExceptionAndShouldNotResetQueueEventsAndNotStopCurrentEventWhenHandlerThrowExceptionTest()
{
string keyMessage = nameof(keyMessage);
bool flagFromIsolateHandlers = false;
bool flagFromIsolateEvent = false;
EventAggregator.AddHandler <IsolateHandlersEvent>(_ => throw new Exception(keyMessage));
EventAggregator.AddHandler <IsolateHandlersEvent>(_ => flagFromIsolateHandlers = true);
EventAggregator.AddHandler <IsolateHandlersEvent>(_ => EventAggregator.Event(new IsolateEvent()));
EventAggregator.AddHandler <IsolateEvent>(_ => flagFromIsolateEvent = true);
LogAssert.Expect(LogType.Exception, new Regex(".keyMessage"));
EventAggregator.Event(new IsolateHandlersEvent());
Assert.True(flagFromIsolateHandlers);
Assert.True(flagFromIsolateEvent);
EventManagerDispatcher <IsolateHandlersEvent> .RemoveEventManagerInternal();
EventManagerDispatcher <IsolateEvent> .RemoveEventManagerInternal();
}
public void WhenPipelineFails_StepsAndCleanupRan([Values] bool shouldThrow)
{
var context = CreateTestContext();
var pipeline = ScriptableObject.CreateInstance <BuildPipeline>();
pipeline.AddSteps(new TestStep1(), new FailStep {
Throw = shouldThrow
}, new TestStep2());
LogAssert.Expect(LogType.Error, s_BuildFailureRegex);
pipeline.RunSteps(context);
var runResults = context.Get <StepRunResults>();
Assert.That(runResults.stepsRan, Is.EqualTo(new[] { "step1", "fail" }));
var cleanResults = context.Get <StepCleanupResults>();
Assert.That(cleanResults.stepsCleaned, Is.EqualTo(new[] { "fail", "step1" }));
}
public void State_StateChangeMonitor_CanBeRemovedFromMonitorCallback()
{
var gamepad = InputSystem.AddDevice <Gamepad>();
var buttonWestMonitor = InputSystem.AddStateChangeMonitor(gamepad.buttonWest,
(c, d, e, m) => { Debug.Log("ButtonWest"); });
InputSystem.AddStateChangeMonitor(gamepad.buttonEast,
(control, time, eventPtr, monitorIndex) =>
{
Debug.Log("ButtonEast");
InputSystem.RemoveStateChangeMonitor(gamepad.buttonWest, buttonWestMonitor);
});
LogAssert.Expect(LogType.Log, "ButtonEast");
Press(gamepad.buttonEast);
LogAssert.NoUnexpectedReceived();
Press(gamepad.buttonWest);
LogAssert.NoUnexpectedReceived();
}
public static void Unreloadable()
{
var target = new Mux.Markup.Transform();
try
{
var reference = new WeakReference <Mux.Markup.IInternalTransform>(target);
Mux.Markup.Transforms.Add("path", reference);
Mux.Markup.Transforms.Reload(new[] { "path" });
LogAssert.Expect(LogType.Log, "Reloadable Mux ancestor not found for Mux.Markup.Transform.");
LogAssert.NoUnexpectedReceived();
Mux.Markup.Transforms.Remove("path", reference);
Mux.Markup.Transforms.Reload(new[] { "path" });
}
finally
{
target.Destroy();
}
}
public void RoutineShouldThrowExceptionIfNestedRoutineHaveErrorTest()
{
var routineWithError = Routine.ByAction(() => throw new Exception("Its test exception"));
LogAssert.Expect(LogType.Error, new Regex("."));
routineWithError.Complete();
IEnumerator TestRoutine(RoutineControl <int> control)
{
yield return(routineWithError);
control.SetResult(50);
}
var routine = Routine.ByEnumerator <int>(TestRoutine);
LogAssert.Expect(LogType.Error, new Regex("."));
routine.Complete();
Assert.True(routine.IsError);
}
[Test] // runtime string formatting
public void ComponentSystemSorter_OrderFirstUpdateAfterOrderLast_WarnAndIgnoreConstraint()
{
var parent = World.CreateSystem <TestGroup>();
var systems = new List <EmptySystem>
{
World.CreateSystem <FirstAfterLastSystem>(),
World.CreateSystem <DummyLastSystem>(),
};
// Insert in reverse order
for (int i = systems.Count - 1; i >= 0; --i)
{
parent.AddSystemToUpdateList(systems[i]);
}
LogAssert.Expect(LogType.Warning, "Ignoring invalid [UpdateAfter(Unity.Entities.Tests.ComponentSystemGroupTests+DummyLastSystem)] attribute on Unity.Entities.Tests.ComponentSystemGroupTests+FirstAfterLastSystem because OrderFirst/OrderLast has higher precedence.");
parent.SortSystems();
LogAssert.NoUnexpectedReceived();
CollectionAssert.AreEqual(systems, parent.Systems);
}
public IEnumerator ServerAndClient_SendMessageWithoutReadingIt_GivesErrorOnDriverUpdate()
{
SetupServerAndClientAndConnectThem(0);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(16, Allocator.Persistent);
m_OutStream.Clear();
m_OutStream.Write(SharedConstants.ping);
clientToServerConnection.Send(client_driver, m_OutStream);
m_OutStream.Dispose();
server_driver.ScheduleUpdate().Complete();
client_driver.ScheduleUpdate().Complete();
LogAssert.Expect(LogType.Error, "Resetting event queue with pending events (Count=1, ConnectionID=0) Listening: 1");
server_driver.ScheduleUpdate().Complete();
DisconnectAndCleanup();
yield return(null);
}
public IEnumerator FailGracefullyWhenIdsCannotBeResolved()
{
avatarModel.wearables = new List <string>()
{
"Scioli_right_arm", "Peron_hands"
};
avatarModel.bodyShape = "Invalid_id";
avatarRenderer.SetVisibility(true);
bool success = false;
avatarRenderer.ApplyModel(avatarModel, () => success = true, null);
yield return(new DCL.WaitUntil(() => success, 4));
LogAssert.Expect(LogType.Error, "Bodyshape Invalid_id not found in catalog");
LogAssert.Expect(LogType.Error, "Wearable Scioli_right_arm not found in catalog");
LogAssert.Expect(LogType.Error, "Wearable Peron_hands not found in catalog");
UnityEngine.Assertions.Assert.IsTrue(success);
}
public void Branch_InsertTree_ReturnsFalse()
{
const int branchUserID = 10;
const int treeUserID = 11;
var tree = CSGTree.Create(treeUserID);
var branch = CSGTreeBranch.Create(branchUserID);
CompactHierarchyManager.ClearDirty(tree);
CompactHierarchyManager.ClearDirty(branch);
var result = branch.Insert(0, tree);
LogAssert.Expect(LogType.Error, new Regex("Cannot add a tree as a child"));
Assert.IsFalse(result);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.IsFalse(tree.Dirty);
Assert.IsFalse(branch.Dirty);
Assert.AreEqual(0, branch.Count);
}
public void TestAddDuplicateUrl()
{
var temp = Path.GetTempFileName();
try
{
File.WriteAllText(temp, "UnityFS");
var request = new MapRequest()
{
name = "name",
url = "file://" + temp,
};
Mock.Reset();
Mock.Setup(srv => srv.Add(It.IsAny <MapModel>())).Throws <Exception>(); // TODO: we need to use more specialized exception here!
MockUser.Reset();
MockDownload.Reset();
MockNotification.Reset();
LogAssert.Expect(LogType.Exception, new Regex("^Exception"));
var result = Browser.Post($"/maps", ctx =>
{
ctx.JsonBody(request);
}).Result;
Assert.AreEqual(HttpStatusCode.InternalServerError, result.StatusCode);
Assert.That(result.ContentType.StartsWith("application/json"));
Mock.Verify(srv => srv.Add(It.Is <MapModel>(m => m.Name == request.name)), Times.Once);
Mock.VerifyNoOtherCalls();
MockUser.VerifyNoOtherCalls();
MockDownload.VerifyNoOtherCalls();
MockNotification.VerifyNoOtherCalls();
}
finally
{
File.Delete(temp);
}
}
public void BranchWithThreeChildren_RemoveWithNegativeIndex_ReturnsFalse()
{
const int branchUserID = 10;
const int brushUserID1 = 11;
const int brushUserID2 = 12;
const int brushUserID3 = 12;
var brush1 = CSGTreeBrush.Create(userID: brushUserID1);
var brush2 = CSGTreeBrush.Create(userID: brushUserID2);
var brush3 = CSGTreeBrush.Create(userID: brushUserID3);
var branch = CSGTreeBranch.Create(branchUserID, new CSGTreeNode[] { brush1, brush2, brush3 });
CompactHierarchyManager.ClearDirty(brush1);
CompactHierarchyManager.ClearDirty(brush2);
CompactHierarchyManager.ClearDirty(brush3);
CompactHierarchyManager.ClearDirty(branch);
var result = branch.RemoveAt(-1);
LogAssert.Expect(LogType.Error, new Regex("must be between"));
Assert.IsFalse(result);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidBrushWithUserID(ref brush1, brushUserID1);
TestUtility.ExpectValidBrushWithUserID(ref brush2, brushUserID2);
TestUtility.ExpectValidBrushWithUserID(ref brush3, brushUserID3);
Assert.IsFalse(brush1.Dirty);
Assert.IsFalse(brush2.Dirty);
Assert.IsFalse(brush3.Dirty);
Assert.IsFalse(branch.Dirty);
Assert.IsFalse(brush1.Tree.Valid);
Assert.IsFalse(brush2.Tree.Valid);
Assert.IsFalse(brush3.Tree.Valid);
Assert.AreEqual(3, branch.Count);
Assert.AreEqual((CSGTreeNode)brush1, (CSGTreeNode)branch[0]);
Assert.AreEqual((CSGTreeNode)brush2, (CSGTreeNode)branch[1]);
Assert.AreEqual((CSGTreeNode)brush3, (CSGTreeNode)branch[2]);
Assert.AreEqual((CSGTreeNode)branch, (CSGTreeNode)brush1.Parent);
Assert.AreEqual((CSGTreeNode)branch, (CSGTreeNode)brush2.Parent);
Assert.AreEqual((CSGTreeNode)branch, (CSGTreeNode)brush3.Parent);
}
public void Test_05_04_UnregisterMixedRealityExtensionServicesByType()
{
TestUtilities.InitializeMixedRealityToolkitScene();
// Add test ExtensionService
MixedRealityToolkit.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1"));
MixedRealityToolkit.RegisterService <ITestExtensionService2>(new TestExtensionService2("Test ExtensionService 2"));
// Retrieve all registered IMixedRealityExtensionServices
var extensionServices = MixedRealityToolkit.GetActiveServices <IMixedRealityExtensionService>();
// Tests
Assert.IsNotNull(MixedRealityToolkit.Instance.ActiveProfile);
Assert.IsEmpty(MixedRealityToolkit.ActiveSystems);
Assert.AreEqual(2, MixedRealityToolkit.RegisteredMixedRealityServices.Count);
Assert.AreEqual(extensionServices.Count, MixedRealityToolkit.RegisteredMixedRealityServices.Count);
// Retrieve services
var extensionService1 = MixedRealityToolkit.GetService <ITestExtensionService1>();
var extensionService2 = MixedRealityToolkit.GetService <ITestExtensionService2>();
// Validate
Assert.IsNotNull(extensionService1);
Assert.IsNotNull(extensionService2);
var success = MixedRealityToolkit.UnregisterServicesOfType <IMixedRealityExtensionService>();
// Validate non-existent service
var isService1Registered = MixedRealityToolkit.IsServiceRegistered <ITestExtensionService1>();
var isService2Registered = MixedRealityToolkit.IsServiceRegistered <ITestExtensionService2>();
// Tests
Assert.IsTrue(success);
Assert.IsFalse(isService1Registered);
Assert.IsFalse(isService2Registered);
Assert.IsEmpty(MixedRealityToolkit.ActiveSystems);
Assert.IsEmpty(MixedRealityToolkit.RegisteredMixedRealityServices);
LogAssert.Expect(LogType.Error, $"Unable to find {typeof(ITestExtensionService1).Name} service.");
LogAssert.Expect(LogType.Error, $"Unable to find {typeof(ITestExtensionService2).Name} service.");
}
public IEnumerator DragCallbacksDoGetCalled()
{
// While left mouse button is pressed and the mouse is moving, OnBeginDrag and OnDrag callbacks should be called
// Then when the left mouse button is released, OnEndDrag callback should be called
// Add script to EventSystem to update the mouse position
m_EventSystem.gameObject.AddComponent <MouseUpdate>();
// Add script to Image which implements OnBeginDrag, OnDrag & OnEndDrag callbacks
m_Image.gameObject.AddComponent <DragCallbackCheck>();
// Setting required input.mousePresent to fake mouse presence
m_FakeBaseInput.MousePresent = true;
yield return(null);
// Left mouse button down simulation
m_FakeBaseInput.MouseButtonDown[0] = true;
yield return(null);
// Left mouse button down flag needs to reset in the next frame
m_FakeBaseInput.MouseButtonDown[0] = false;
yield return(null);
// Left mouse button up simulation
m_FakeBaseInput.MouseButtonUp[0] = true;
yield return(null);
// Left mouse button up flag needs to reset in the next frame
m_FakeBaseInput.MouseButtonUp[0] = false;
yield return(null);
LogAssert.Expect(LogType.Log, "OnBeginDrag");
LogAssert.Expect(LogType.Log, "OnDrag");
LogAssert.Expect(LogType.Log, "OnEndDrag");
}
public void TestLogStringsWithNonConnectedPorts()
{
m_Node.Messages.DataCount = 5;
CustomSetup();
var stringRef4 = new StringReference {
Index = 4
};
var stringRef2 = new StringReference {
Index = 2
};
m_GraphInstanceMock.Setup(x => x.GetString(stringRef4)).Returns(new NativeString128("4"));
m_GraphInstanceMock.Setup(x => x.GetString(stringRef2)).Returns(new NativeString128("2"));
m_GraphInstanceMock.Setup(x => x.ReadValue(m_Node.Messages.SelectPort(0))).Returns(new Value());
m_GraphInstanceMock.Setup(x => x.ReadValue(m_Node.Messages.SelectPort(1))).Returns(stringRef4);
m_GraphInstanceMock.Setup(x => x.ReadValue(m_Node.Messages.SelectPort(2))).Returns(new Value());
m_GraphInstanceMock.Setup(x => x.ReadValue(m_Node.Messages.SelectPort(3))).Returns(stringRef2);
m_GraphInstanceMock.Setup(x => x.ReadValue(m_Node.Messages.SelectPort(4))).Returns(new Value());
TriggerPort(m_Node.Input);
LogAssert.Expect(LogType.Log, "Unknown4Unknown2Unknown");
AssertPortTriggered(m_Node.Output, Times.Once());
}
[Test] // TODO: fix jobs
public void OnEnterAndExitWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, graphModel =>
{
var group = graphModel.CreateComponentQuery("g");
var positionType = typeof(Translation).GenerateTypeHandle(Stencil);
group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None);
group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero);
var update = graphModel.CreateNode <OnStartEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort);
var set = update.CreateStackedNode <SetPositionNodeModel>("set", 0, SpawnFlags.Default, n => n.Mode = SetPositionNodeModel.TranslationMode.Float3);
set.Add = true; // increment so we can detect multiple runs if they happen
((Float3ConstantModel)set.InputConstantsById["Value"]).value = new Vector3(1f, 0.0f, 0.0f);
IVariableModel posComponent = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
IVariableModel entityVariable = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == typeof(Entity).GenerateTypeHandle(Stencil)), Vector2.zero);
GraphModel.CreateEdge(log.GetParameterPorts().First(), entityVariable.OutputPort);
},
EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))),
EachEntity((manager, i, e) =>
{
manager.AddComponent(e, typeof(Translation)); // will make the entity enter the query
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0));
}),
EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // translate ran once
EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // not twice
EachEntity((manager, i, e) =>
{
LogAssert.Expect(LogType.Log, $"Entity({i}:1)");
manager.RemoveComponent <Rotation>(e);
}),
EachEntity((manager, i, e) => {})
);
}
public void TestSerialPortsList()
{
var serialPorts = new SerialPorts();
var portsCount = serialPorts.GetPortsCount();
if (portsCount <= 0)
{
LogAssert.Expect(LogType.Error, "no ports");
}
for (uint i = 0; i < portsCount; i++)
{
var portInfo = serialPorts.GetPortAt(i);
Assert.True(portInfo.IsValid);
}
// invalid port index
{
var portInfo = serialPorts.GetPortAt(portsCount + 1);
Assert.True(!portInfo.IsValid);
}
}
public void Test_PlayerGainsNoPointsAfterTryingToKillADeadEnemy()
{
PlayerStatsClass player = new PlayerStatsClass();
player.AttackDamage = 500;
IGameController mockController = Substitute.For <IGameController>();
mockController.GetPlayerStats().Returns(player);
EnemyStatsClass enemy = new EnemyStatsClass();
enemy.SetUpEnemyStats(mockController);
player.AttackOpponent(enemy, false, true);
int pointsAfterFirstKill = player.GetCurrentPoints();
player.AttackOpponent(enemy, false, true);
int pointsAfterSecondKill = player.GetCurrentPoints();
Assert.AreEqual(pointsAfterFirstKill, pointsAfterSecondKill, "Player received points after trying to kill an enemy that's already dead!");
LogAssert.Expect(LogType.Warning, "Fighter tried to attack an opponent that already died. Can't attack dead opponents!");
}
public IEnumerator BundledCatalog_LoadCatalogFromBundle_WhenCalledMultipleTimes_OpNotCompleted_FirstShouldSucceedAndOthersShouldFail()
{
var bundleFilePath = Path.Combine(Addressables.RuntimePath, m_RuntimeCatalogFilename);
var timesCalled = 0;
var bundledCatalog = new ContentCatalogProvider.InternalOp.BundledCatalog(bundleFilePath);
bundledCatalog.OnLoaded += catalogData =>
{
Assert.NotNull(catalogData);
Assert.AreEqual(ResourceManagerRuntimeData.kCatalogAddress, catalogData.ProviderId);
timesCalled++;
};
bundledCatalog.LoadCatalogFromBundleAsync();
bundledCatalog.LoadCatalogFromBundleAsync();
LogAssert.Expect(LogType.Error, new Regex("progress", RegexOptions.IgnoreCase));
yield return(new WaitWhile(() => bundledCatalog.OpInProgress));
Assert.AreEqual(1, timesCalled);
}
public void EntityManagerDestructionDetectsUnregisteredJob()
{
#if !UNITY_DOTSPLAYER
LogAssert.Expect(LogType.Error, new System.Text.RegularExpressions.Regex("job is still running"));
#endif
/*var entity =*/ m_Manager.CreateEntity(typeof(EcsTestData));
var group = m_Manager.CreateEntityQuery(typeof(EcsTestData));
var job = new TestIncrementJob();
job.entities = group.ToEntityArray(Allocator.TempJob);
job.data = m_Manager.GetComponentDataFromEntity <EcsTestData>();
var jobHandle = job.Schedule();
// This call should detect the unregistered running job & emit the expected error message
TearDown();
// Manually complete the job before cleaning up for real
jobHandle.Complete();
TearDown();
job.entities.Dispose();
}