public void Load_ShouldLoadInputMappingFromFile(LoadTestCase testCase)
{
// Arrange
const string filePath = "input mapping file path";
var assetInfo = new AssetInfo(AssetId.CreateUnique(), InputAssetTypes.InputMapping, filePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, testCase.InputMappingAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var file = Substitute.For <IFile>();
file.OpenRead().Returns(memoryStream);
_fileSystem.GetFile(filePath).Returns(file);
var inputMappingAssetLoader = new InputMappingAssetLoader(_fileSystem);
// Act
var actual = (InputMapping)inputMappingAssetLoader.LoadAsset(assetInfo, _assetStore);
// Assert
testCase.Assert(actual);
}
public void SerializeAndDeserialize_WhenSpriteIsNotNull()
{
// Arrange
var texture = Substitute.For <ITexture>();
var sprite = new Sprite(texture, Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var spriteAssetId = AssetId.CreateUnique();
var component = new SpriteRendererComponent
{
Visible = false,
SortingLayerName = "Some sorting layer",
OrderInLayer = 2,
Sprite = sprite
};
AssetStore.GetAssetId(sprite).Returns(spriteAssetId);
AssetStore.GetAsset <Sprite>(spriteAssetId).Returns(sprite);
// Act
var actual = SerializeAndDeserialize(component);
// Assert
Assert.That(actual.Visible, Is.EqualTo(component.Visible));
Assert.That(actual.SortingLayerName, Is.EqualTo(component.SortingLayerName));
Assert.That(actual.OrderInLayer, Is.EqualTo(component.OrderInLayer));
Assert.That(actual.Sprite, Is.EqualTo(sprite));
}
public void SerializeAndDeserialize_WhenInputMappingIsNotNull()
{
// Arrange
var inputMapping = new InputMapping();
var inputMappingAssetId = AssetId.CreateUnique();
var component = new InputComponent
{
InputMapping = inputMapping
};
AssetStore.GetAssetId(inputMapping).Returns(inputMappingAssetId);
AssetStore.GetAsset <InputMapping>(inputMappingAssetId).Returns(inputMapping);
// Act
var actual = SerializeAndDeserialize(component);
// Assert
Assert.That(actual.InputMapping, Is.EqualTo(inputMapping));
Assert.That(actual.HardwareInput, Is.EqualTo(HardwareInput.Empty));
Assert.That(actual.ActionBindings, Is.Empty);
Assert.That(actual.AxisBindings, Is.Empty);
Assert.That(actual.ActionStates, Is.Empty);
Assert.That(actual.AxisStates, Is.Empty);
}
public void SerializeAndDeserialize_WhenCurrentAnimationIsNull()
{
// Arrange
var animation = CreateAnimation();
var animationAssetId = AssetId.CreateUnique();
var component = new SpriteAnimationComponent();
component.AddAnimation("animation", animation);
component.Position = 0.7;
component.PlaybackSpeed = 1.3;
component.PlayInLoop = true;
AssetStore.GetAssetId(animation).Returns(animationAssetId);
AssetStore.GetAsset <SpriteAnimation>(animationAssetId).Returns(animation);
// Act
var actual = SerializeAndDeserialize(component);
// Assert
Assert.That(actual.Animations, Has.Count.EqualTo(1));
Assert.That(actual.Animations.Single().Key, Is.EqualTo("animation"));
Assert.That(actual.Animations.Single().Value, Is.EqualTo(animation));
Assert.That(actual.CurrentAnimation, Is.Null);
Assert.That(actual.IsPlaying, Is.False);
Assert.That(actual.Position, Is.EqualTo(component.Position));
Assert.That(actual.PlaybackSpeed, Is.EqualTo(component.PlaybackSpeed));
Assert.That(actual.PlayInLoop, Is.EqualTo(component.PlayInLoop));
}
public void GetAsset_ShouldThrowException_WhenAssetWasNotRegistered()
{
// Arrange
var notRegisteredAssetId = AssetId.CreateUnique();
var assetStore = GetAssetStore();
// Act
// Assert
Assert.That(() => assetStore.GetAsset <object>(notRegisteredAssetId), Throws.TypeOf <AssetNotRegisteredException>());
}
public void CreateUnique_CreatesUniqueAssetIds()
{
// Arrange
// Act
var assetId1 = AssetId.CreateUnique();
var assetId2 = AssetId.CreateUnique();
// Assert
Assert.That(assetId1, Is.Not.EqualTo(assetId2));
}
public void LoadAsset_ShouldLoadSpriteFromFile()
{
// Arrange
const string assetFilePath = @"some_directory\sprite_file_path";
var textureAssetId = AssetId.CreateUnique();
var spriteAssetContent = new SpriteAssetContent
{
TextureAssetId = textureAssetId.Value,
SourceUV = new SerializableVector2 {
X = 123.456, Y = 234.567
},
SourceDimensions = new SerializableVector2 {
X = 345.456, Y = 456.567
},
Pivot = new SerializableVector2 {
X = 567.678, Y = 678.789
},
PixelsPerUnit = 123.456
};
var assetInfo = new AssetInfo(AssetId.CreateUnique(), RenderingAssetTypes.Sprite, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, spriteAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
var fileSystem = Substitute.For <IFileSystem>();
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var assetStore = Substitute.For <IAssetStore>();
var texture = Substitute.For <ITexture>();
assetStore.GetAsset <ITexture>(textureAssetId).Returns(texture);
var spriteAssetLoader = new SpriteAssetLoader(fileSystem);
// Act
var actual = (Sprite)spriteAssetLoader.LoadAsset(assetInfo, assetStore);
// Assert
Assert.That(actual.SourceTexture, Is.EqualTo(texture));
Assert.That(actual.SourceUV.X, Is.EqualTo(spriteAssetContent.SourceUV.X));
Assert.That(actual.SourceUV.Y, Is.EqualTo(spriteAssetContent.SourceUV.Y));
Assert.That(actual.SourceDimensions.X, Is.EqualTo(spriteAssetContent.SourceDimensions.X));
Assert.That(actual.SourceDimensions.Y, Is.EqualTo(spriteAssetContent.SourceDimensions.Y));
Assert.That(actual.Pivot.X, Is.EqualTo(spriteAssetContent.Pivot.X));
Assert.That(actual.Pivot.Y, Is.EqualTo(spriteAssetContent.Pivot.Y));
Assert.That(actual.PixelsPerUnit, Is.EqualTo(spriteAssetContent.PixelsPerUnit));
}
public void UnloadAsset_ShouldThrowException_GivenIdOfNotRegisteredAsset()
{
// Arrange
var assetId = AssetId.CreateUnique();
var assetStore = GetAssetStore();
// Act
// Assert
Assert.That(() => { assetStore.UnloadAsset(assetId); }, Throws.TypeOf <AssetNotRegisteredException>());
}
public void GetAsset_ShouldThrowException_WhenThereIsAssetTypeMismatch()
{
// Arrange
var assetId = AssetId.CreateUnique();
var assetStore = GetAssetStore();
assetStore.RegisterAsset(new AssetInfo(assetId, new AssetType("AssetType.Object"), "some file path"));
// Act
// Assert
Assert.That(() => assetStore.GetAsset <int>(assetId), Throws.TypeOf <AssetNotRegisteredException>());
}
public void SerializeAndDeserialize_AssetId()
{
// Arrange
_component.AssetIdProperty = AssetId.CreateUnique();
TestComponent.SerializeAction = (component, writer) => writer.WriteAssetId("AssetIdProperty", component.AssetIdProperty);
TestComponent.DeserializeAction = (component, reader) => component.AssetIdProperty = reader.ReadAssetId("AssetIdProperty");
// Act
var actual = SerializeAndDeserialize(_component);
// Assert
Assert.That(actual.AssetIdProperty, Is.EqualTo(_component.AssetIdProperty));
}
public void SetUp()
{
_assetId = AssetId.CreateUnique();
_assetType = new AssetType("AssetType");
_buffer = new byte[1000];
Utils.Random.NextBytes(_buffer);
_binaryContent = new MemoryStream(_buffer);
_jsonContent = new JsonContent
{
IntProperty = 123,
DoubleProperty = 123.456,
StringProperty = "String 123"
};
}
public void SetUp()
{
var renderingBackend = Substitute.For <IRenderingBackend>();
var renderer2D = Substitute.For <IRenderer2D>();
var fileSystem = Substitute.For <IFileSystem>();
_assetStore = Substitute.For <IAssetStore>();
renderingBackend.Renderer2D.Returns(renderer2D);
const string assetFilePath = @"some_directory\texture_file_path";
const string textureFilePath = @"some_directory\actual_texture_file_path";
var textureAssetContent = new TextureAssetContent
{
TextureFilePath = "actual_texture_file_path"
};
_assetInfo = new AssetInfo(AssetId.CreateUnique(), RenderingAssetTypes.Texture, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(_assetInfo.AssetId, _assetInfo.AssetType, textureAssetContent);
var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var stream = Substitute.For <Stream>();
var textureFile = Substitute.For <IFile>();
textureFile.OpenRead().Returns(stream);
fileSystem.GetFile(textureFilePath).Returns(textureFile);
_texture = Substitute.For <ITexture>();
renderer2D.CreateTexture(stream).Returns(_texture);
_textureAssetLoader = new TextureAssetLoader(renderingBackend, fileSystem);
}
public void SerializeAndDeserialize_WhenSoundIsNotNull()
{
// Arrange
var sound = Substitute.For <ISound>();
var soundAssetId = AssetId.CreateUnique();
var component = new AudioSourceComponent
{
Sound = sound,
IsPlaying = true
};
AssetStore.GetAssetId(sound).Returns(soundAssetId);
AssetStore.GetAsset <ISound>(soundAssetId).Returns(sound);
// Act
var actual = SerializeAndDeserialize(component);
// Assert
Assert.That(actual.Sound, Is.EqualTo(sound));
Assert.That(actual.IsPlaying, Is.True);
}
public void SetUp()
{
_audioBackend = Substitute.For <IAudioBackend>();
_fileSystem = Substitute.For <IFileSystem>();
_assetStore = Substitute.For <IAssetStore>();
const string soundFilePath = "sound.wav";
const SoundFormat soundFormat = SoundFormat.Wav;
const string assetFilePath = "sound-asset-path";
var soundAssetContent = new SoundAssetContent
{
SoundFilePath = soundFilePath
};
_assetInfo = new AssetInfo(AssetId.CreateUnique(), AudioAssetTypes.Sound, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(_assetInfo.AssetId, _assetInfo.AssetType, soundAssetContent);
var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
_fileSystem.GetFile(assetFilePath).Returns(assetFile);
var soundFile = Substitute.For <IFile>();
var stream = Substitute.For <Stream>();
soundFile.OpenRead().Returns(stream);
_fileSystem.GetFile(soundFilePath).Returns(soundFile);
_sound = Substitute.For <ISound>();
_audioBackend.CreateSound(stream, soundFormat).Returns(_sound);
_soundAssetLoader = new SoundAssetLoader(_audioBackend, _fileSystem);
}
public void LoadAsset_ThrowsException_WhenFileContentIsInvalid(LoadThrowsExceptionTestCase testCase)
{
// Arrange
const string assetFilePath = "input mapping file path";
var assetInfo = new AssetInfo(AssetId.CreateUnique(), InputAssetTypes.InputMapping, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, testCase.InputMappingAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var file = Substitute.For <IFile>();
file.OpenRead().Returns(memoryStream);
_fileSystem.GetFile(assetFilePath).Returns(file);
var inputMappingAssetLoader = new InputMappingAssetLoader(_fileSystem);
// Act
// Assert
Assert.That(() => inputMappingAssetLoader.LoadAsset(assetInfo, _assetStore), Throws.TypeOf <InvalidInputMappingAssetContentException>());
}
public void SerializeAndDeserialize_Object()
{
// Arrange
_component.ObjectProperty = new TestComponent.CustomData
{
BoolProperty = true,
IntProperty = 123,
DoubleProperty = 123.456,
StringProperty = "value",
EnumProperty = DateTimeKind.Utc,
Vector2Property = new Vector2(12.34, 56.78),
Vector3Property = new Vector3(1.23, 4.56, 7.89),
AssetIdProperty = AssetId.CreateUnique(),
ColorProperty = Color.FromArgb(1, 2, 3, 4),
ObjectProperty = new TestComponent.CustomNestedData
{
IntProperty = 321,
DoubleProperty = 654.321
}
};
TestComponent.SerializeAction = (component, writer) => writer.WriteObject("ObjectProperty", component.ObjectProperty, (customData, objectWriter) =>
{
objectWriter.WriteNull("NullProperty");
objectWriter.WriteBool("BoolProperty", customData.BoolProperty);
objectWriter.WriteInt("IntProperty", customData.IntProperty);
objectWriter.WriteDouble("DoubleProperty", customData.DoubleProperty);
objectWriter.WriteString("StringProperty", customData.StringProperty);
objectWriter.WriteEnum("EnumProperty", customData.EnumProperty);
objectWriter.WriteVector2("Vector2Property", customData.Vector2Property);
objectWriter.WriteVector3("Vector3Property", customData.Vector3Property);
objectWriter.WriteAssetId("AssetIdProperty", customData.AssetIdProperty);
objectWriter.WriteColor("ColorProperty", customData.ColorProperty);
objectWriter.WriteObject("ObjectProperty", customData.ObjectProperty, (customNestedData, nestedWriter) =>
{
nestedWriter.WriteInt("IntProperty", customNestedData.IntProperty);
nestedWriter.WriteDouble("DoubleProperty", customNestedData.DoubleProperty);
});
});
var actualDefined = false;
var actualUndefined = true;
var actualNull = false;
var actualNotNull = true;
string[] objectProperties = Array.Empty <string>();
string[] nestedObjectProperties = Array.Empty <string>();
TestComponent.DeserializeAction = (component, reader) =>
{
objectProperties = reader.EnumerateObject("ObjectProperty").ToArray();
component.ObjectProperty = reader.ReadObject("ObjectProperty", objectReader =>
{
actualDefined = objectReader.IsDefined("BoolProperty");
actualUndefined = objectReader.IsDefined("UndefinedProperty");
actualNull = objectReader.IsNull("NullProperty");
actualNotNull = objectReader.IsNull("BoolProperty");
nestedObjectProperties = objectReader.EnumerateObject("ObjectProperty").ToArray();
return(new TestComponent.CustomData
{
BoolProperty = objectReader.ReadBool("BoolProperty"),
IntProperty = objectReader.ReadInt("IntProperty"),
DoubleProperty = objectReader.ReadDouble("DoubleProperty"),
StringProperty = objectReader.ReadString("StringProperty"),
EnumProperty = objectReader.ReadEnum <DateTimeKind>("EnumProperty"),
Vector2Property = objectReader.ReadVector2("Vector2Property"),
Vector3Property = objectReader.ReadVector3("Vector3Property"),
AssetIdProperty = objectReader.ReadAssetId("AssetIdProperty"),
ColorProperty = objectReader.ReadColor("ColorProperty"),
ObjectProperty = objectReader.ReadObject("ObjectProperty", nestedReader => new TestComponent.CustomNestedData
{
IntProperty = nestedReader.ReadInt("IntProperty"),
DoubleProperty = nestedReader.ReadDouble("DoubleProperty")
})
});
});
};
// Act
var actual = SerializeAndDeserialize(_component);
// Assert
Assert.That(actualDefined, Is.True);
Assert.That(actualUndefined, Is.False);
Assert.That(actualNull, Is.True);
Assert.That(actualNotNull, Is.False);
Assert.That(actual.ObjectProperty.BoolProperty, Is.EqualTo(_component.ObjectProperty.BoolProperty));
Assert.That(actual.ObjectProperty.IntProperty, Is.EqualTo(_component.ObjectProperty.IntProperty));
Assert.That(actual.ObjectProperty.DoubleProperty, Is.EqualTo(_component.ObjectProperty.DoubleProperty));
Assert.That(actual.ObjectProperty.StringProperty, Is.EqualTo(_component.ObjectProperty.StringProperty));
Assert.That(actual.ObjectProperty.EnumProperty, Is.EqualTo(_component.ObjectProperty.EnumProperty));
Assert.That(actual.ObjectProperty.Vector2Property, Is.EqualTo(_component.ObjectProperty.Vector2Property));
Assert.That(actual.ObjectProperty.Vector3Property, Is.EqualTo(_component.ObjectProperty.Vector3Property));
Assert.That(actual.ObjectProperty.AssetIdProperty, Is.EqualTo(_component.ObjectProperty.AssetIdProperty));
Assert.That(actual.ObjectProperty.ColorProperty, Is.EqualTo(_component.ObjectProperty.ColorProperty));
Assert.That(actual.ObjectProperty.ObjectProperty.IntProperty, Is.EqualTo(_component.ObjectProperty.ObjectProperty.IntProperty));
Assert.That(actual.ObjectProperty.ObjectProperty.DoubleProperty, Is.EqualTo(_component.ObjectProperty.ObjectProperty.DoubleProperty));
Assert.That(objectProperties, Has.Length.EqualTo(11));
Assert.That(objectProperties,
Is.EqualTo(new[]
{
"NullProperty", "BoolProperty", "IntProperty", "DoubleProperty", "StringProperty", "EnumProperty", "Vector2Property", "Vector3Property",
"AssetIdProperty", "ColorProperty", "ObjectProperty"
}));
Assert.That(nestedObjectProperties, Has.Length.EqualTo(2));
Assert.That(nestedObjectProperties, Is.EqualTo(new[] { "IntProperty", "DoubleProperty" }));
}
private static AssetInfo CreateNewAssetInfo()
{
return(new AssetInfo(AssetId.CreateUnique(), new AssetType("AssetType.Object"), AssetFileUtils.AppendExtension("asset-file")));
}
public void LoadAsset_ShouldLoadSpriteAnimationFromFile()
{
// Arrange
const string assetFilePath = @"some_directory\sprite_animation_file_path";
const int duration = 123;
var sprite1AssetId = AssetId.CreateUnique();
var sprite2AssetId = AssetId.CreateUnique();
var sprite3AssetId = AssetId.CreateUnique();
var spriteAnimationAssetContent = new SpriteAnimationAssetContent
{
DurationTicks = TimeSpan.FromSeconds(duration).Ticks,
Frames = new[]
{
new SpriteAnimationAssetContent.Frame
{
Duration = 1,
SpriteAssetId = sprite1AssetId.Value
},
new SpriteAnimationAssetContent.Frame
{
Duration = 1.5,
SpriteAssetId = sprite2AssetId.Value
},
new SpriteAnimationAssetContent.Frame
{
Duration = 0.5,
SpriteAssetId = sprite3AssetId.Value
}
}
};
var assetInfo = new AssetInfo(AssetId.CreateUnique(), AnimationAssetTypes.SpriteAnimation, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, spriteAnimationAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var sprite1 = new Sprite(Substitute.For <ITexture>(), Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var sprite2 = new Sprite(Substitute.For <ITexture>(), Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var sprite3 = new Sprite(Substitute.For <ITexture>(), Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
var fileSystem = Substitute.For <IFileSystem>();
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var assetStore = Substitute.For <IAssetStore>();
assetStore.GetAsset <Sprite>(sprite1AssetId).Returns(sprite1);
assetStore.GetAsset <Sprite>(sprite2AssetId).Returns(sprite2);
assetStore.GetAsset <Sprite>(sprite3AssetId).Returns(sprite3);
var spriteAnimationManagedAsset = new SpriteAnimationAssetLoader(fileSystem);
// Act
var actual = (SpriteAnimation)spriteAnimationManagedAsset.LoadAsset(assetInfo, assetStore);
// Assert
Assert.That(actual.Duration, Is.EqualTo(TimeSpan.FromSeconds(duration)));
Assert.That(actual.Frames, Has.Count.EqualTo(3));
Assert.That(actual.Frames[0].Duration, Is.EqualTo(1));
Assert.That(actual.Frames[0].Sprite, Is.EqualTo(sprite1));
Assert.That(actual.Frames[1].Duration, Is.EqualTo(1.5));
Assert.That(actual.Frames[1].Sprite, Is.EqualTo(sprite2));
Assert.That(actual.Frames[2].Duration, Is.EqualTo(0.5));
Assert.That(actual.Frames[2].Sprite, Is.EqualTo(sprite3));
}
