public void SceneBehavior_ShouldUpdateSceneBehaviorOfTheScene_WhenChanged()
{
// Arrange
const string oldSceneBehaviorName = "Old scene behavior";
const string newSceneBehaviorName = "New scene behavior";
var scene = TestSceneFactory.Create();
var oldSceneBehavior = Substitute.ForPartsOf <SceneBehavior>(scene);
oldSceneBehavior.Name.Returns(oldSceneBehaviorName);
var newSceneBehavior = Substitute.ForPartsOf <SceneBehavior>(scene);
newSceneBehavior.Name.Returns(newSceneBehaviorName);
var newSceneBehaviorFactory = Substitute.For <ISceneBehaviorFactory>();
newSceneBehaviorFactory.Create(scene).Returns(newSceneBehavior);
_sceneBehaviorFactoryProvider.Configure().Get(newSceneBehaviorName).Returns(newSceneBehaviorFactory);
scene.SceneBehavior = oldSceneBehavior;
var sceneModel = CreateSceneModel(scene);
// Act
sceneModel.SceneBehavior = new SceneBehaviorName(newSceneBehaviorName);
// Assert
Assert.That(scene.SceneBehavior, Is.EqualTo(newSceneBehavior));
Assert.That(sceneModel.SceneBehavior.Value, Is.EqualTo("New scene behavior"));
}
public void SelectedSceneModelChangedEvent_ShouldAddItems()
{
// Arrange
var sceneOutlineViewModel = CreateSceneOutlineViewModel();
var scene = TestSceneFactory.Create();
scene.AddEntity(new Entity {
Name = "Entity"
});
var sceneModel = TestSceneModelFactory.Create(scene);
// Act
_eventBus.SendEvent(new SelectedSceneModelChangedEvent(sceneModel));
// Assert
Assert.That(sceneOutlineViewModel.Items, Has.Count.EqualTo(1));
var sceneRootViewModel = sceneOutlineViewModel.Items.Single();
Assert.That(sceneRootViewModel.Name, Is.EqualTo("Scene"));
Assert.That(sceneRootViewModel.Items, Has.Count.EqualTo(1));
var entityViewModel = sceneRootViewModel.Items.Single();
Assert.That(entityViewModel.Name, Is.EqualTo("Entity"));
Assert.That(entityViewModel.Items, Has.Count.Zero);
}
public void UpdateDiagnostics_ShouldCauseGetDiagnosticInfoReturn_RootEntitiesCount_Of3_And_AllEntitiesCount_Of5()
{
// Arrange
var configurationBuilder = CoreConfiguration.CreateBuilder();
configurationBuilder.WithShowRootEntitiesCount(true);
configurationBuilder.WithShowAllEntitiesCount(true);
var entity1 = new Entity();
entity1.AddChild(new Entity());
var entity2 = new Entity();
entity2.AddChild(new Entity());
var entity3 = new Entity();
var scene = TestSceneFactory.Create();
scene.AddEntity(entity1);
scene.AddEntity(entity2);
scene.AddEntity(entity3);
var coreDiagnosticInfoProvider = GetCoreDiagnosticInfoProvider(configurationBuilder.Build());
// Act
coreDiagnosticInfoProvider.UpdateDiagnostics(scene);
// Assert
var diagnosticInfo = coreDiagnosticInfoProvider.GetDiagnosticInfo().ToList();
var rootEntitiesCount = diagnosticInfo.Single(di => di.Name == "RootEntitiesCount").Value;
var allEntitiesCount = diagnosticInfo.Single(di => di.Name == "AllEntitiesCount").Value;
Assert.That(rootEntitiesCount, Is.EqualTo(3.ToString()));
Assert.That(allEntitiesCount, Is.EqualTo(5.ToString()));
}
public void Create_ShouldReturnSceneModelWithAvailableSceneBehaviorsForEachAvailableSceneBehaviorFactory()
{
// Arrange
var sceneBehaviorFactoryProvider = Substitute.For <ISceneBehaviorFactoryProvider>();
var sceneBehaviorFactory1 = Substitute.For <ISceneBehaviorFactory>();
sceneBehaviorFactory1.BehaviorName.Returns("Behavior 1");
var sceneBehaviorFactory2 = Substitute.For <ISceneBehaviorFactory>();
sceneBehaviorFactory2.BehaviorName.Returns("Behavior 2");
var sceneBehaviorFactory3 = Substitute.For <ISceneBehaviorFactory>();
sceneBehaviorFactory3.BehaviorName.Returns("Behavior 3");
var sceneModelFactory = new SceneModelFactory(sceneBehaviorFactoryProvider,
new[] { sceneBehaviorFactory1, sceneBehaviorFactory2, sceneBehaviorFactory3 });
var scene = TestSceneFactory.Create();
var sceneBehaviorName1 = new SceneBehaviorName("Behavior 1");
var sceneBehaviorName2 = new SceneBehaviorName("Behavior 2");
var sceneBehaviorName3 = new SceneBehaviorName("Behavior 3");
// Act
var sceneModel = sceneModelFactory.Create(scene);
// Assert
Assert.That(sceneModel.AvailableSceneBehaviors, Is.EquivalentTo(new[] { sceneBehaviorName1, sceneBehaviorName2, sceneBehaviorName3 }));
}
public void Update_ShouldExecuteFixedTimeStepSystemsCorrectNumberOfTimes(double deltaTime, int fixedUpdatesPerFrameLimit, int expectedFixedUpdateCount)
{
// Arrange
GameTime.FixedDeltaTime = TimeSpan.FromSeconds(0.1);
var gameTime = new GameTime(TimeSpan.FromSeconds(deltaTime));
_gameTimeProvider.GetGameTime().Returns(gameTime);
var scene = TestSceneFactory.Create();
_sceneManager.CurrentScene.Returns(scene);
var gameLoop = GetGameLoop(CoreConfiguration.CreateBuilder().WithFixedUpdatesPerFrameLimit(fixedUpdatesPerFrameLimit).Build());
// Act
gameLoop.Update();
// Assert
Received.InOrder(() =>
{
for (var i = 0; i < expectedFixedUpdateCount; i++)
{
_inputSystem.Received(1).ProcessInput(scene);
_behaviorSystem.Received(1).ProcessBehaviorFixedUpdate(scene);
_customSystem1.Received(1).ProcessFixedUpdate(scene);
_customSystem2.Received(1).ProcessFixedUpdate(scene);
_customSystem3.Received(1).ProcessFixedUpdate(scene);
_physicsSystem.Received(1).ProcessPhysics(scene);
_entityDestructionSystem.Received(1).DestroyEntitiesAfterFixedTimeStep(scene);
}
});
}
public void OnNextFrame_HandlesLoadEmptySceneOnlyOnce()
{
// Arrange
const string sceneBehaviorName = "Behavior name";
var scene1 = TestSceneFactory.Create();
SetUpSceneBehavior(sceneBehaviorName, scene1);
_sceneFactory.Create().Returns(scene1);
_sceneManager.LoadEmptyScene(sceneBehaviorName);
_sceneManager.OnNextFrame();
Assume.That(_sceneManager.CurrentScene, Is.EqualTo(scene1));
var scene2 = TestSceneFactory.Create();
SetUpSceneBehavior(sceneBehaviorName, scene2);
_sceneFactory.Create().Returns(scene2);
// Act
_sceneManager.OnNextFrame();
// Assert
Assert.That(_sceneManager.CurrentScene, Is.EqualTo(scene1));
}
public void Serialize_and_Deserialize_SceneWithEntityWithComponentAccessingAssetStoreDuringSerialization()
{
// Arrange
var entity = new Entity();
var componentToSerialize = new AssetStoreTestComponent();
entity.AddComponent(componentToSerialize);
var scene = TestSceneFactory.Create();
scene.AddEntity(entity);
_componentFactoryProvider.Get(ComponentId.Of <AssetStoreTestComponent>()).Returns(new AssetStoreTestComponent.Factory());
// Act
var actual = SerializeAndDeserialize(scene);
// Assert
Assert.That(componentToSerialize.SerializeAssetStore, Is.EqualTo(_assetStore));
Assert.That(actual, Is.Not.Null);
Assert.That(actual.RootEntities, Has.Count.EqualTo(1));
var actualEntity = actual.RootEntities.Single();
Assert.That(actualEntity.Components, Has.Count.EqualTo(1));
var deserializedComponent = actualEntity.Components.ElementAt(0);
Assert.That(deserializedComponent, Is.TypeOf <AssetStoreTestComponent>());
Assert.That(((AssetStoreTestComponent)deserializedComponent).DeserializeAssetStore, Is.EqualTo(_assetStore));
}
public void SetUp()
{
_sceneFactory = Substitute.For <ISceneFactory>();
_sceneFactory.Create().Returns(ci => TestSceneFactory.Create());
_sceneSerializer = Substitute.For <ISceneSerializer>();
_createEmptySceneService = new CreateEmptySceneService(_sceneFactory, _sceneSerializer);
}
public void AddEntity_ShouldAddNewRootEntityAndNotifyWithEvent()
{
// Arrange
var scene = TestSceneFactory.Create();
var sceneModel = CreateSceneModel(scene);
object?eventSender = null;
EntityAddedEventArgs?eventArgs = null;
sceneModel.EntityAdded += (sender, args) =>
{
eventSender = sender;
eventArgs = args;
};
// Act
sceneModel.AddEntity();
// Assert
Assert.That(sceneModel.RootEntities, Has.Count.EqualTo(1));
Assert.That(scene.RootEntities, Has.Count.EqualTo(1));
var entityModel = sceneModel.RootEntities.Single();
var entity = scene.RootEntities.Single();
Assert.That(entityModel.Name, Is.EqualTo("Entity 1"));
Assert.That(entity.Name, Is.EqualTo("Entity 1"));
Assert.That(eventSender, Is.EqualTo(sceneModel));
Debug.Assert(eventArgs != null, nameof(eventArgs) + " != null");
Assert.That(eventArgs.EntityModel, Is.EqualTo(entityModel));
}
public void Constructor_ShouldCreateSceneModelWithNoAvailableSceneBehaviors()
{
// Arrange
var scene = TestSceneFactory.Create();
// Act
var sceneModel = CreateSceneModel(scene);
// Assert
Assert.That(sceneModel.AvailableSceneBehaviors, Is.Empty);
}
public void Constructor_ShouldLoadTheSceneFromFile()
{
// Arrange
_sceneLoader.Load(SceneFilePath).Returns(TestSceneFactory.Create());
// Act
_ = new SceneEditorViewModel(SceneFilePath, _eventBus, _sceneLoader, _sceneModelFactory);
// Assert
_sceneLoader.Received(1).Load(SceneFilePath);
}
public void Constructor_ShouldCreateSceneModelWithEntitiesHierarchy()
{
// Arrange
var entity1 = new Entity {
Name = "Entity 1"
};
var entity11 = new Entity {
Name = "Entity 1.1", Parent = entity1
};
_ = new Entity {
Name = "Entity 1.1.1", Parent = entity11
};
_ = new Entity {
Name = "Entity 1.2", Parent = entity1
};
var entity2 = new Entity {
Name = "Entity 2"
};
var scene = TestSceneFactory.Create();
scene.AddEntity(entity1);
scene.AddEntity(entity2);
// Act
var sceneModel = CreateSceneModel(scene);
// Assert
Assert.That(sceneModel.RootEntities, Has.Count.EqualTo(2));
var entityModel1 = sceneModel.RootEntities.First();
var entityModel2 = sceneModel.RootEntities.Last();
Assert.That(entityModel1.Name, Is.EqualTo("Entity 1"));
Assert.That(entityModel2.Name, Is.EqualTo("Entity 2"));
Assert.That(entityModel1.Children, Has.Count.EqualTo(2));
Assert.That(entityModel2.Children, Has.Count.Zero);
var entityModel11 = entityModel1.Children.First();
var entityModel12 = entityModel1.Children.Last();
Assert.That(entityModel11.Name, Is.EqualTo("Entity 1.1"));
Assert.That(entityModel12.Name, Is.EqualTo("Entity 1.2"));
Assert.That(entityModel11.Children, Has.Count.EqualTo(1));
Assert.That(entityModel12.Children, Has.Count.Zero);
var entityModel111 = entityModel11.Children.Single();
Assert.That(entityModel111.Name, Is.EqualTo("Entity 1.1.1"));
Assert.That(entityModel111.Children, Has.Count.Zero);
}
public void Serialize_and_Deserialize_EmptyScene()
{
// Arrange
var scene = TestSceneFactory.Create();
// Act
var actual = SerializeAndDeserialize(scene);
// Assert
Assert.That(actual, Is.Not.Null);
Assert.That(actual.RootEntities, Has.Count.Zero);
Assert.That(actual.SceneBehavior.Name, Is.EqualTo(SceneBehavior.CreateEmpty(actual).Name));
}
public void AddEntity_ShouldAddEntitiesWithIncrementingDefaultNames_WhenSceneInitiallyEmpty()
{
// Arrange
var scene = TestSceneFactory.Create();
var sceneModel = CreateSceneModel(scene);
// Act
sceneModel.AddEntity();
sceneModel.AddEntity();
sceneModel.AddEntity();
// Assert
Assert.That(sceneModel.RootEntities.Select(e => e.Name), Is.EquivalentTo(new[] { "Entity 1", "Entity 2", "Entity 3" }));
}
public void RenderScene_Should_EndRendering_WithWaitForVSync_BasedOnRenderingConfiguration(bool enableVSync)
{
// Arrange
SetupVSync(enableVSync);
var renderingSystem = GetRenderingSystem();
var scene = TestSceneFactory.Create();
// Act
renderingSystem.RenderScene(scene);
// Assert
_renderer2D.Received().EndRendering(enableVSync);
}
public void LoadScene_And_OnNextFrame_ShouldLoadSceneAndSetAsCurrent_GivenPathToSceneFile()
{
// Arrange
const string sceneFilePath = "start up scene";
var scene = TestSceneFactory.Create();
_sceneLoader.Load(sceneFilePath).Returns(scene);
// Act
_sceneManager.LoadScene(sceneFilePath);
_sceneManager.OnNextFrame();
// Assert
Assert.That(_sceneManager.CurrentScene, Is.EqualTo(scene));
}
protected TComponent SerializeAndDeserialize <TComponent>(TComponent component) where TComponent : Component
{
var sceneSerializer = CreateSerializer(component.ComponentId);
var sceneToSerialize = TestSceneFactory.Create();
var entity = new Entity();
entity.AddComponent(component);
sceneToSerialize.AddEntity(entity);
var json = sceneSerializer.Serialize(sceneToSerialize);
var deserializedScene = sceneSerializer.Deserialize(json);
return(deserializedScene.RootEntities.Single().GetComponent <TComponent>());
}
public void LoadScene_And_OnNextFrame_ShouldUnloadAssets_GivenUnloadAssetsSceneLoadMode()
{
// Arrange
const string sceneFilePath = "start up scene";
var scene = TestSceneFactory.Create();
_sceneLoader.Load(sceneFilePath).Returns(scene);
// Act
_sceneManager.LoadScene(sceneFilePath, SceneLoadMode.UnloadAssets);
_sceneManager.OnNextFrame();
// Assert
_assetStore.Received().UnloadAssets();
}
public void Scene_ShouldSetSceneOnChild_WhenChanged()
{
// Arrange
var scene = TestSceneFactory.Create();
var parent = GetNewEntity();
var child = GetNewEntity();
child.Parent = parent;
// Act
scene.AddEntity(parent);
// Assert
Assert.That(child.Scene, Is.EqualTo(scene));
}
public void SaveDocument_ShouldSaveSceneToFile()
{
// Arrange
var scene = TestSceneFactory.Create();
_sceneLoader.Load(SceneFilePath).Returns(scene);
var sceneEditorViewModel = new SceneEditorViewModel(SceneFilePath, _eventBus, _sceneLoader, _sceneModelFactory);
// Act
sceneEditorViewModel.SaveDocument();
// Assert
_sceneLoader.Received(1).Save(scene, SceneFilePath);
}
public void AddChild_ShouldSetSceneOnChild_WhenParentHasScene_AndChildAddedToChildrenOfParent()
{
// Arrange
var scene = TestSceneFactory.Create();
var parent = GetNewEntity();
var child = GetNewEntity();
scene.AddEntity(parent);
// Act
parent.AddChild(child);
// Assert
Assert.That(child.Scene, Is.EqualTo(scene));
}
public void Constructor_ShouldCreateSceneModelWithSceneBehaviorMatchingSceneBehaviorOfScene()
{
// Arrange
var scene = TestSceneFactory.Create();
var sceneBehavior = Substitute.ForPartsOf <SceneBehavior>(scene);
sceneBehavior.Name.Returns("Scene behavior");
scene.SceneBehavior = sceneBehavior;
// Act
var sceneModel = CreateSceneModel(scene);
// Assert
Assert.That(sceneModel.SceneBehavior.Value, Is.EquivalentTo("Scene behavior"));
}
public void Parent_ShouldUnsetSceneOnChild_WhenParentHasScene_AndParentSetToNull()
{
// Arrange
var scene = TestSceneFactory.Create();
var parent = GetNewEntity();
var child = GetNewEntity();
scene.AddEntity(parent);
child.Parent = parent;
// Act
child.Parent = null;
// Assert
Assert.That(child.Scene, Is.Null);
}
public void Constructor_ShouldCreateSceneModelWithAvailableSceneBehaviors()
{
// Arrange
var scene = TestSceneFactory.Create();
var sceneBehavior1 = new SceneBehaviorName("Behavior 1");
var sceneBehavior2 = new SceneBehaviorName("Behavior 2");
var sceneBehavior3 = new SceneBehaviorName("Behavior 3");
// Act
var sceneModel = CreateSceneModel(scene, sceneBehavior1, sceneBehavior2, sceneBehavior3);
// Assert
Assert.That(sceneModel.AvailableSceneBehaviors, Has.Count.EqualTo(3));
Assert.That(sceneModel.AvailableSceneBehaviors.Select(b => b.Value), Is.EquivalentTo(new[] { "Behavior 1", "Behavior 2", "Behavior 3" }));
}
public void LoadEmptyScene_And_OnNextFrame_ShouldUnloadAssets_GivenUnloadAssetsSceneLoadMode()
{
// Arrange
const string sceneBehaviorName = "Behavior name";
var scene = TestSceneFactory.Create();
SetUpSceneBehavior(sceneBehaviorName, scene);
_sceneFactory.Create().Returns(scene);
// Act
_sceneManager.LoadEmptyScene(sceneBehaviorName, SceneLoadMode.UnloadAssets);
_sceneManager.OnNextFrame();
// Assert
_assetStore.Received().UnloadAssets();
}
public void Serialize_and_Deserialize_SceneWithRootEntities()
{
// Arrange
var scene = TestSceneFactory.Create();
scene.AddEntity(new Entity());
scene.AddEntity(new Entity());
scene.AddEntity(new Entity());
// Act
var actual = SerializeAndDeserialize(scene);
// Assert
Assert.That(actual, Is.Not.Null);
Assert.That(actual.RootEntities, Has.Count.EqualTo(3));
}
public void LoadScene_And_OnNextFrame_ShouldNotUnloadAssets_GivenPreserveAssetsSceneLoadMode()
{
// Arrange
const string sceneFilePath = "start up scene";
var scene = TestSceneFactory.Create();
_sceneLoader.Load(sceneFilePath).Returns(scene);
// Act
// ReSharper disable once RedundantArgumentDefaultValue
_sceneManager.LoadScene(sceneFilePath, SceneLoadMode.PreserveAssets);
_sceneManager.OnNextFrame();
// Assert
_assetStore.DidNotReceive().UnloadAssets();
}
public void LoadEmptyScene_And_OnNextFrame_ShouldExecuteOnLoadedOfSceneBehaviorForLoadedScene()
{
// Arrange
const string sceneBehaviorName = "Behavior name";
var scene = TestSceneFactory.Create();
var sceneBehavior = SetUpSceneBehavior(sceneBehaviorName, scene);
_sceneFactory.Create().Returns(scene);
// Act
_sceneManager.LoadEmptyScene(sceneBehaviorName);
_sceneManager.OnNextFrame();
// Assert
sceneBehavior.Received(1).OnLoaded();
}
public void DestroyEntitiesAfterFixedTimeStep_ShouldNotRemoveEntityFromScene_WhenNoDestroyMethodIsExecutedForEntity()
{
// Arrange
var scene = TestSceneFactory.Create();
var entity = new Entity();
scene.AddEntity(entity);
// Assume
Assert.That(scene.AllEntities, Contains.Item(entity));
// Act
_entityDestructionSystem.DestroyEntitiesAfterFixedTimeStep(scene);
// Assert
Assert.That(scene.AllEntities, Contains.Item(entity));
}
public void LoadEmptyScene_And_OnNextFrame_ShouldNotUnloadAssets_GivenPreserveAssetsSceneLoadMode()
{
// Arrange
const string sceneBehaviorName = "Behavior name";
var scene = TestSceneFactory.Create();
SetUpSceneBehavior(sceneBehaviorName, scene);
_sceneFactory.Create().Returns(scene);
// Act
// ReSharper disable once RedundantArgumentDefaultValue
_sceneManager.LoadEmptyScene(sceneBehaviorName, SceneLoadMode.PreserveAssets);
_sceneManager.OnNextFrame();
// Assert
_assetStore.DidNotReceive().UnloadAssets();
}
