public void TestSimpleDeserialization()
{
var asset = AssetFileSerializer.Load <Types.MyAssetHierarchy>(AssetTestContainer.ToStream(SimpleHierarchyYaml), $"MyAsset{Types.FileExtension}");
Assert.Equal(2, asset.Asset.Hierarchy.RootParts.Count);
Assert.Equal(GuidGenerator.Get(2), asset.Asset.Hierarchy.RootParts[0].Id);
Assert.Equal(GuidGenerator.Get(1), asset.Asset.Hierarchy.RootParts[1].Id);
Assert.Equal(2, asset.Asset.Hierarchy.Parts.Count);
Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(1)));
Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(2)));
}
public void TestBasicPackageCreateSaveLoad()
{
PackageSessionPublicHelper.FindAndSetMSBuildVersion();
var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad";
string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sdpkg");
// Force the PackageId to be the same each time we run the test
// Usually the PackageId is unique and generated each time we create a new project
var project = new Package {
FullPath = testGenerated1
};
project.AssetFolders.Clear();
project.AssetFolders.Add(new AssetFolder("."));
var session = new PackageSession(project);
// Write the solution when saving
session.SolutionPath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sln");
// Delete the solution before saving it
if (File.Exists(session.SolutionPath))
{
File.Delete(session.SolutionPath);
}
var result = new LoggerResult();
session.Save(result);
Assert.False(result.HasErrors);
// Reload the raw package and if UFile and UDirectory were saved relative
var rawPackage = AssetFileSerializer.Load <Package>(testGenerated1).Asset;
var rawSourceFolder = rawPackage.AssetFolders.FirstOrDefault();
Assert.NotNull(rawSourceFolder);
Assert.Equal(".", (string)rawSourceFolder.Path);
// Reload the package directly from the sdpkg
var project2Result = PackageSession.Load(testGenerated1);
AssertResult(project2Result);
var project2 = project2Result.Session.LocalPackages.FirstOrDefault();
Assert.NotNull(project2);
Assert.True(project2.AssetFolders.Count > 0);
var sourceFolder = project.AssetFolders.First().Path;
Assert.Equal(sourceFolder, project2.AssetFolders.First().Path);
}
public static DeriveAssetTest <T> LoadFromYaml(string baseYaml, string derivedYaml)
{
var baseAsset = AssetFileSerializer.Load <T>(ToStream(baseYaml), $"MyAsset{Types.FileExtension}");
var derivedAsset = AssetFileSerializer.Load <T>(ToStream(derivedYaml), $"MyDerivedAsset{Types.FileExtension}");
var result = new DeriveAssetTest <T>(baseAsset.Asset, derivedAsset.Asset)
{
BaseAssetItem = { Overrides = baseAsset.Overrides },
DerivedAssetItem = { Overrides = derivedAsset.Overrides }
};
result.BuildGraph();
return(result);
}
public void TestMissortedPartsDeserialization()
{
var asset = AssetFileSerializer.Load <Types.MyAssetHierarchy>(AssetTestContainer.ToStream(MissortedHierarchyYaml), $"MyAsset{Types.FileExtension}");
Assert.Equal(2, asset.Asset.Hierarchy.RootParts.Count);
Assert.Equal(GuidGenerator.Get(2), asset.Asset.Hierarchy.RootParts[0].Id);
Assert.Equal(GuidGenerator.Get(1), asset.Asset.Hierarchy.RootParts[1].Id);
Assert.Equal(4, asset.Asset.Hierarchy.Parts.Count);
Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(1)));
Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(2)));
Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(3)));
Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(4)));
Assert.Single(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(3)].Part.Children);
Assert.Equal(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(2)].Part, asset.Asset.Hierarchy.Parts[GuidGenerator.Get(3)].Part.Children[0]);
Assert.Single(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(4)].Part.Children);
Assert.Equal(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(1)].Part, asset.Asset.Hierarchy.Parts[GuidGenerator.Get(4)].Part.Children[0]);
}
public void TestSerialization()
{
var originAsset = CreateOriginAsset();
using (var stream = new MemoryStream())
{
AssetFileSerializer.Save(stream, originAsset);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newAsset = AssetFileSerializer.Load <PrefabAsset>(stream, "Prefab.xkprefab").Asset;
CheckAsset(originAsset, newAsset);
}
}
public static DeriveAssetTest <TAsset, TAssetPropertyGraph> LoadFromYaml(string baseYaml, string derivedYaml)
{
var container = new AssetPropertyGraphContainer(new AssetNodeContainer {
NodeBuilder = { NodeFactory = new AssetNodeFactory() }
});
var baseAsset = AssetFileSerializer.Load <TAsset>(AssetTestContainer.ToStream(baseYaml), $"MyAsset{Types.FileExtension}");
var derivedAsset = AssetFileSerializer.Load <TAsset>(AssetTestContainer.ToStream(derivedYaml), $"MyDerivedAsset{Types.FileExtension}");
var baseContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, baseAsset.Asset);
var derivedContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, derivedAsset.Asset);
baseAsset.YamlMetadata.CopyInto(baseContainer.AssetItem.YamlMetadata);
derivedAsset.YamlMetadata.CopyInto(derivedContainer.AssetItem.YamlMetadata);
baseContainer.BuildGraph();
derivedContainer.BuildGraph();
var result = new DeriveAssetTest <TAsset, TAssetPropertyGraph>(baseContainer, derivedContainer, null);
derivedContainer.Graph.RefreshBase();
return(result);
}
public void TestUpgrade(MyUpgradedAsset asset, bool needMigration)
{
var loadingFilePath = new PackageLoadingAssetFile(Path.Combine(DirectoryTestBase, "TestUpgrade\\Asset1.xkobj"), DirectoryTestBase);
var outputFilePath = loadingFilePath.FilePath.FullPath;
AssetFileSerializer.Save(outputFilePath, asset, null);
var logger = new LoggerResult();
var context = new AssetMigrationContext(null, loadingFilePath.ToReference(), loadingFilePath.FilePath.ToWindowsPath(), logger);
Assert.AreEqual(AssetMigration.MigrateAssetIfNeeded(context, loadingFilePath, "TestPackage"), needMigration);
if (needMigration)
{
using (var fileStream = new FileStream(outputFilePath, FileMode.Truncate))
fileStream.Write(loadingFilePath.AssetContent, 0, loadingFilePath.AssetContent.Length);
}
Console.WriteLine(File.ReadAllText(outputFilePath).Trim());
var upgradedAsset = AssetFileSerializer.Load <MyUpgradedAsset>(outputFilePath).Asset;
AssertUpgrade(upgradedAsset);
}
public void TestMyAssetObject()
{
var assetObject = new MyAsset();
assetObject.Id = AssetId.Empty;
assetObject.Description = "This is a test";
assetObject.AssetDirectory = new UDirectory("/test/dynamic/path/to/file/in/object/property");
assetObject.AssetUrl = new UFile("/test/dynamic/path/to/file/in/object/property");
//assetObject.Base = new AssetBase("/this/is/an/url/to/MyObject", null);
assetObject.CustomReference2 = new AssetReference(AssetId.Empty, "/this/is/an/url/to/MyCustomReference2");
assetObject.CustomReferences.Add(new AssetReference(AssetId.Empty, "/this/is/an/url/to/MyCustomReferenceItem1"));
var ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.CustomReferences);
ids[0] = IdentifierGenerator.Get(99);
assetObject.SeqItems1.Add("value1");
assetObject.SeqItems1.Add("value2");
ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems1);
ids[0] = IdentifierGenerator.Get(1);
ids[1] = IdentifierGenerator.Get(2);
// TODO: Re-enable non-pure collections here once we support them for serialization!
//assetObject.SeqItems2.Add("value1");
//assetObject.SeqItems2.Add("value2");
//assetObject.SeqItems2.Add("value3");
//ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems2);
//ids[0] = IdentifierGenerator.Get(3);
//ids[1] = IdentifierGenerator.Get(4);
//ids[2] = IdentifierGenerator.Get(5);
assetObject.SeqItems3.Add("value1");
assetObject.SeqItems3.Add("value2");
assetObject.SeqItems3.Add("value3");
assetObject.SeqItems3.Add("value4");
ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems3);
ids[0] = IdentifierGenerator.Get(6);
ids[1] = IdentifierGenerator.Get(7);
ids[2] = IdentifierGenerator.Get(8);
ids[3] = IdentifierGenerator.Get(9);
assetObject.SeqItems4.Add("value0");
ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems4);
ids[0] = IdentifierGenerator.Get(10);
// TODO: Re-enable non-pure collections here once we support them for serialization!
//assetObject.SeqItems5.Add("value0");
//ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems5);
//ids[0] = IdentifierGenerator.Get(11);
assetObject.MapItems1.Add("key1", 1);
assetObject.MapItems1.Add("key2", 2);
ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.MapItems1);
ids["key1"] = IdentifierGenerator.Get(12);
ids["key2"] = IdentifierGenerator.Get(13);
// TODO: Re-enable non-pure collections here once we support them for serialization!
//assetObject.MapItems2.Add("key1", 1);
//assetObject.MapItems2.Add("key2", 2);
//assetObject.MapItems2.Add("key3", 3);
//ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.MapItems2);
//ids["key1"] = IdentifierGenerator.Get(13);
//ids["key2"] = IdentifierGenerator.Get(14);
//ids["key3"] = IdentifierGenerator.Get(15);
assetObject.MapItems3.Add("key1", 1);
assetObject.MapItems3.Add("key2", 2);
assetObject.MapItems3.Add("key3", 3);
assetObject.MapItems3.Add("key4", 3);
ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.MapItems3);
ids["key1"] = IdentifierGenerator.Get(16);
ids["key2"] = IdentifierGenerator.Get(17);
ids["key3"] = IdentifierGenerator.Get(18);
ids["key4"] = IdentifierGenerator.Get(19);
string testGenerated1 = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Generated1.sdobj";
string testGenerated2 = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Generated2.sdobj";
string referenceFilePath = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Reference.sdobj";
// First store the file on the disk and compare it to the reference
GenerateAndCompare("Test Serialization 1", testGenerated1, referenceFilePath, assetObject);
// Deserialize it
var newAssetObject = AssetFileSerializer.Load <MyAsset>(testGenerated1).Asset;
// Restore the deserialize version and compare it with the reference
GenerateAndCompare("Test Serialization 2 - double check", testGenerated2, referenceFilePath, newAssetObject);
}
public void TestBasicPackageCreateSaveLoad()
{
PackageSessionPublicHelper.FindAndSetMSBuildVersion();
var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad";
string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.xkpkg");
string testGenerated2 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated2.xkpkg");
string referenceFilePath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Reference.xkpkg");
// Force the PackageId to be the same each time we run the test
// Usually the PackageId is unique and generated each time we create a new project
var project = new Package {
Id = Guid.Empty, FullPath = testGenerated1
};
var sharedProfile = new PackageProfile("Shared", new AssetFolder("."));
project.Profiles.Add(sharedProfile);
var projectReference = new ProjectReference(Guid.Empty, Path.Combine(dirPath, "test.csproj"), ProjectType.Executable);
sharedProfile.ProjectReferences.Add(projectReference);
var session = new PackageSession(project);
// Write the solution when saving
session.SolutionPath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sln");
// Delete the solution before saving it
if (File.Exists(session.SolutionPath))
{
File.Delete(session.SolutionPath);
}
var result = new LoggerResult();
session.Save(result);
Assert.False(result.HasErrors);
// Reload the raw package and if UFile and UDirectory were saved relative
var rawPackage = AssetFileSerializer.Load <Package>(testGenerated1).Asset;
var rawPackageSharedProfile = rawPackage.Profiles.FirstOrDefault();
Assert.NotNull(rawPackageSharedProfile);
var rawSourceFolder = rawPackage.Profiles.First().AssetFolders.FirstOrDefault();
Assert.NotNull(rawSourceFolder);
Assert.Equal(".", (string)rawSourceFolder.Path);
Assert.Equal("test.csproj", (string)rawPackageSharedProfile.ProjectReferences[0].Location);
// Reload the package directly from the xkpkg
var project2Result = PackageSession.Load(testGenerated1);
AssertResult(project2Result);
var project2 = project2Result.Session.LocalPackages.FirstOrDefault();
Assert.NotNull(project2);
Assert.Equal(project.Id, project2.Id);
Assert.True(project2.Profiles.Count > 0);
Assert.True(project2.Profiles.First().AssetFolders.Count > 0);
Assert.Equal(project2, project2Result.Session.CurrentPackage); // Check that the current package is setup when loading a single package
var sourceFolder = project.Profiles.First().AssetFolders.First().Path;
Assert.Equal(sourceFolder, project2.Profiles.First().AssetFolders.First().Path);
// Reload the package from the sln
var sessionResult = PackageSession.Load(session.SolutionPath);
Assert.False(sessionResult.HasErrors);
var sessionReload = sessionResult.Session;
Assert.Equal(1, sessionReload.LocalPackages.Count());
Assert.Equal(project.Id, sessionReload.LocalPackages.First().Id);
Assert.Equal(1, sessionReload.LocalPackages.First().Profiles.Count);
var sharedProfileReload = sessionReload.LocalPackages.First().Profiles.First();
Assert.Equal(1, sharedProfileReload.ProjectReferences.Count);
Assert.Equal(projectReference, sharedProfileReload.ProjectReferences[0]);
}
