/// <summary> /// Initializes a new instance of the <see cref="PackageSessionAnalysis" /> class. /// </summary> /// <param name="packageSession">The package session.</param> /// <param name="parameters">The parameters.</param> public PackageSessionAnalysis(PackageSession packageSession, PackageAnalysisParameters parameters) : base(packageSession) { if (parameters == null) throw new ArgumentNullException("parameters"); this.parameters = (PackageAnalysisParameters)parameters.Clone(); this.parameters.IsPackageCheckDependencies = true; }
/// <inheritdoc/> public override IEnumerable<string> Select(PackageSession packageSession, IContentIndexMap contentIndexMap) { // Check if we need to create or regenerate regex. bool needGenerateRegex = false; if (regexes == null || regexes.Length != Paths.Count) { needGenerateRegex = true; } else { // Check used pattern for (int i = 0; i < Paths.Count; ++i) { if (Paths[i] != regexes[i].Key) { needGenerateRegex = true; break; } } } // Transform gitignore patterns to regex. if (needGenerateRegex) regexes = Paths.Select(x => new KeyValuePair<string, Regex>(x, new Regex(TransformToRegex(x)))).ToArray(); return contentIndexMap.GetMergedIdMap() .Select(asset => asset.Key) // Select url .Where(assetUrl => regexes.Any(regex => regex.Value.IsMatch(assetUrl))); // Check if any Regex matches }
public void TestUpdateAssetUrl() { var projectDir = new UFile(Path.Combine(Environment.CurrentDirectory, "testxk")); // Create a project with an asset reference a raw file var project = new Package { FullPath = projectDir }; var assetItem = new AssetItem("test", new AssetObjectTest() { Reference = new AssetReference<AssetObjectTest>(Guid.Empty, "good/location")}); project.Assets.Add(assetItem); var goodAsset = new AssetObjectTest(); project.Assets.Add(new AssetItem("good/location", goodAsset)); // Add the project to the session to make sure analysis will run correctly var session = new PackageSession(project); // Create a session with this project var analysis = new PackageAnalysis(project, new PackageAnalysisParameters() { IsProcessingAssetReferences = true, ConvertUPathTo = UPathType.Absolute, IsProcessingUPaths = true }); var result = analysis.Run(); Assert.IsFalse(result.HasErrors); Assert.AreEqual(1, result.Messages.Count); Assert.IsTrue(result.Messages[0].ToString().Contains("changed")); var asset = (AssetObjectTest)assetItem.Asset; Assert.AreEqual(goodAsset.Id, asset.Reference.Id); Assert.AreEqual("good/location", asset.Reference.Location); }
/// <inheritdoc/> public override bool UpgradeAfterAssetsLoaded(PackageSession session, ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage, PackageVersionRange dependencyVersionBeforeUpdate) { if (dependencyVersionBeforeUpdate.MinVersion < new PackageVersion("1.3.0-alpha02")) { // Add everything as root assets (since we don't know what the project was doing in the code before) foreach (var assetItem in dependentPackage.Assets) { if (!AssetRegistry.IsAssetTypeAlwaysMarkAsRoot(assetItem.Asset.GetType())) { dependentPackage.RootAssets.Add(new AssetReference <Asset>(assetItem.Id, assetItem.Location)); } } } if (dependencyVersionBeforeUpdate.MinVersion < new PackageVersion("1.6.0-beta")) { // Mark all assets dirty to force a resave foreach (var assetItem in dependentPackage.Assets) { if (!(assetItem.Asset is SourceCodeAsset)) { assetItem.IsDirty = true; } } } return(true); }
private static PackageSession GenerateNewGame(string outputFolder) { // Find the game template description for a new game var template = TemplateManager.FindTemplates().FirstOrDefault(matchTemplate => matchTemplate.Id == NewGameTemplateGenerator.TemplateId); Assert.NotNull(template); var result = new LoggerResult(); var session = new PackageSession(); session.SolutionPath = Path.Combine(outputFolder, @"NewGame.sln"); var parameters = new SessionTemplateGeneratorParameters { Description = template, Logger = result, Name = "NewGame", OutputDirectory = outputFolder, Session = session, Unattended = true, }; NewGameTemplateGenerator.SetParameters(parameters, AssetRegistry.SupportedPlatforms.Where(x => x.Type == Core.PlatformType.Windows).Select(x => new SelectedSolutionPlatform(x, null))); var templateGenerator = TemplateManager.FindTemplateGenerator(parameters); templateGenerator.PrepareForRun(parameters); templateGenerator.Run(parameters); return(session); }
public override IEnumerable<string> Select(PackageSession packageSession, IContentIndexMap contentIndexMap) { return packageSession.Packages .SelectMany(package => package.Assets) // Select all assets .Where(assetItem => assetItem.Asset.Tags.Any(tag => Tags.Contains(tag))) // Matches tags .Select(x => x.Location.FullPath); // Convert to string; }
/// <summary> /// Finds all template descriptions. /// </summary> /// <returns>A sequence containing all registered template descriptions.</returns> public static IEnumerable <TemplateDescription> FindTemplates(PackageSession session = null) { var packages = session?.Packages.Concat(ExtraPackages) ?? ExtraPackages; // TODO this will not work if the same package has different versions return(packages.SelectMany(package => package.Templates).OrderBy(tpl => tpl.Order).ThenBy(tpl => tpl.Name).ToList()); }
public void CompilerVisitRuntimeType() { var package = new Package(); // ReSharper disable once UnusedVariable - we need a package session to compile var packageSession = new PackageSession(package); var otherAssets = new List <AssetItem> { new AssetItem("contentRB", new MyAssetContentType(0), package), new AssetItem("contentRA", new MyAssetContentType(1), package), new AssetItem("content0B", new MyAssetContentType(2), package), new AssetItem("content0M", new MyAssetContentType(3), package), new AssetItem("content0A", new MyAssetContentType(4), package), new AssetItem("content1B", new MyAssetContentType(5), package), new AssetItem("content1M", new MyAssetContentType(6), package), new AssetItem("content1A", new MyAssetContentType(7), package), new AssetItem("content2B", new MyAssetContentType(8), package), new AssetItem("content2M", new MyAssetContentType(9), package), new AssetItem("content2A", new MyAssetContentType(10), package), new AssetItem("content3B", new MyAssetContentType(11), package), new AssetItem("content3M", new MyAssetContentType(12), package), new AssetItem("content3A", new MyAssetContentType(13), package), new AssetItem("content4B", new MyAssetContentType(14), package), new AssetItem("content4M", new MyAssetContentType(15), package), new AssetItem("content4A", new MyAssetContentType(16), package), }; var assetToVisit = new MyAsset1(); assetToVisit.Before = AttachedReferenceManager.CreateProxyObject <MyContentType>(otherAssets[0].Id, otherAssets[0].Location); assetToVisit.Zafter = AttachedReferenceManager.CreateProxyObject <MyContentType>(otherAssets[1].Id, otherAssets[1].Location); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[2], otherAssets[3], otherAssets[4])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[5], otherAssets[6], otherAssets[7])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[8], otherAssets[9], otherAssets[10])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[11], otherAssets[12], otherAssets[13])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[14], otherAssets[15], otherAssets[16])); assetToVisit.RuntimeTypes[0].A = assetToVisit.RuntimeTypes[1]; assetToVisit.RuntimeTypes[0].B = assetToVisit.RuntimeTypes[2]; assetToVisit.RuntimeTypes[1].A = assetToVisit.RuntimeTypes[3]; assetToVisit.RuntimeTypes[1].B = assetToVisit.RuntimeTypes[4]; otherAssets.ForEach(x => package.Assets.Add(x)); var assetItem = new AssetItem("asset", assetToVisit, package); package.Assets.Add(assetItem); package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location)); // Create context var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; // Builds the project var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); context.Properties.Set(BuildAssetNode.VisitRuntimeTypes, true); var assetBuildResult = assetBuilder.Prepare(context); Assert.AreEqual(16, assetBuildResult.BuildSteps.Count); }
public void TestInheritance() { // ----------------------------------------------------------- // Tests inheritance // ----------------------------------------------------------- // 4 assets // [asset1] is referencing [asset2] // [asset2] // [asset3] is inheriting [asset1] // We create a [project1] with [asset1, asset2, asset3] // Check direct inherit dependencies for [asset3]: [asset1] // ----------------------------------------------------------- var asset1 = new AssetObjectTest(); var asset2 = new AssetObjectTest(); var assetItem1 = new AssetItem("asset-1", asset1); var assetItem2 = new AssetItem("asset-2", asset2); var asset3 = assetItem1.CreateChildAsset(); var assetItem3 = new AssetItem("asset-3", asset3); asset1.Reference = new AssetReference<AssetObjectTest>(assetItem2.Id, assetItem2.Location); var project = new Package(); project.Assets.Add(assetItem1); project.Assets.Add(assetItem2); project.Assets.Add(assetItem3); // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; // Verify inheritance { var assets = dependencyManager.FindAssetsInheritingFrom(asset1.Id); Assert.AreEqual(1, assets.Count); Assert.AreEqual(asset3.Id, assets[0].Id); } // Remove the inheritance var copyBase = asset3.Base; asset3.Base = null; assetItem3.IsDirty = true; { var assets = dependencyManager.FindAssetsInheritingFrom(asset1.Id); Assert.AreEqual(0, assets.Count); } // Add back the inheritance asset3.Base = copyBase; assetItem3.IsDirty = true; { var assets = dependencyManager.FindAssetsInheritingFrom(asset1.Id); Assert.AreEqual(1, assets.Count); Assert.AreEqual(asset3.Id, assets[0].Id); } } }
public IEnumerable <IReference> EnumerateCompileTimeDependencies(PackageSession session) { foreach (var shapeDesc in ColliderShapes.OfType <ConvexHullColliderShapeDesc>()) { var reference = AttachedReferenceManager.GetAttachedReference(shapeDesc.Model); yield return(new AssetReference(reference.Id, reference.Url)); } }
/// <summary> /// Collects all references of an asset dynamically. /// </summary> /// <param name="result">The result.</param> /// <param name="packageSession">The package session.</param> /// <param name="isRecursive">if set to <c>true</c> [is recursive].</param> /// <param name="keepParents">Indicate if the parent of the provided <paramref name="result"/> should be kept or not</param> /// <exception cref="System.ArgumentNullException">packageSession</exception> private static void CollectDynamicOutReferences(AssetDependencies result, PackageSession packageSession, bool isRecursive, bool keepParents) { if (packageSession == null) { throw new ArgumentNullException(nameof(packageSession)); } CollectDynamicOutReferences(result, packageSession.FindAsset, isRecursive, keepParents); }
/// <summary> /// Initializes a new instance of the <see cref="TemplateGeneratorContext"/> class. /// </summary> /// <param name="session">The session.</param> public TemplateGeneratorContext(PackageSession session) { if (session == null) { throw new ArgumentNullException("session"); } Session = session; }
/// <summary> /// Initializes a new instance of the <see cref="PackageSessionAnalysis" /> class. /// </summary> /// <param name="packageSession">The package session.</param> /// <exception cref="System.ArgumentNullException">packageSession</exception> protected PackageSessionAnalysisBase(PackageSession packageSession) { if (packageSession == null) { throw new ArgumentNullException("packageSession"); } this.packageSession = packageSession; }
public IEnumerable <IReference> EnumerateCompileTimeDependencies(PackageSession session) { var gameSettings = session.CurrentPackage?.Assets.Find(GameSettingsAsset.GameSettingsLocation); if (gameSettings != null) { yield return(new AssetReference(gameSettings.Id, gameSettings.Location)); } }
/// <summary> /// Creates a build step that will build all shaders from system packages. /// </summary> /// <param name="session">The session used to retrieve currently used system packages.</param> /// <returns>A <see cref="ListBuildStep"/> containing the steps to build all shaders from system packages.</returns> /// <exception cref="ArgumentNullException"><paramref name="session"/> is a <c>null</c> reference.</exception> public ListBuildStep CreateSystemShaderBuildSteps(SessionViewModel session) { if (session is null) { throw new ArgumentNullException(nameof(session)); } // Check if there are any new system projects to preload // TODO: PDX-1251: For now, allow non-system project as well (which means they will be loaded only once at startup) // Later, they should be imported depending on what project the currently previewed/built asset is var systemPackages = session.AllPackages.Where(project => /*project.IsSystem &&*/ !systemProjectsLoaded.Contains(project.Package.Meta.Name)).ToList(); if (systemPackages.Count == 0) { return(null); } var importShadersRootProject = new StandalonePackage(new Package()); var importShadersProjectSession = new PackageSession(); importShadersProjectSession.Projects.Add(importShadersRootProject); foreach (var package in systemPackages) { var mapPackage = new Package { FullPath = package.PackagePath }; foreach (var asset in package.Assets) { if (typeof(EffectShaderAsset).IsAssignableFrom(asset.AssetType)) { mapPackage.Assets.Add(new AssetItem(asset.Url, asset.Asset) { SourceFolder = asset.AssetItem.SourceFolder, AlternativePath = asset.AssetItem.AlternativePath }); } } importShadersProjectSession.Projects.Add(new StandalonePackage(mapPackage)); importShadersRootProject.FlattenedDependencies.Add(new Dependency(mapPackage)); } // Compile the fake project (create the build steps) var assetProjectCompiler = new PackageCompiler(new PackageAssetEnumerator(importShadersRootProject.Package)); var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; var dependenciesCompileResult = assetProjectCompiler.Prepare(context); context.Dispose(); var buildSteps = dependenciesCompileResult.BuildSteps; buildSteps?.Add(new UpdateImportShaderCacheBuildStep(systemProjectsLoaded, systemPackages.Select(x => x.Package.Meta.Name).ToList())); return(buildSteps); }
/// <summary> /// Finds all template descriptions. /// </summary> /// <returns>A sequence containing all registered template descriptions.</returns> public static IEnumerable <TemplateDescription> FindTemplates(PackageSession session = null) { var packages = session?.Packages ?? new PackageCollection { PackageStore.Instance.DefaultPackage }; // TODO this will not work if the same package has different versions return(packages.SelectMany(package => package.Templates).OrderBy(tpl => tpl.Order).ThenBy(tpl => tpl.Name)); }
public PackageAssetsCompiler(PackageSession session) : base(assetCompilerRegistry) { if (session == null) { throw new ArgumentNullException("session"); } this.session = session; }
public void TestRuntime() { var package = new Package(); // ReSharper disable once UnusedVariable - we need a package session to compile var packageSession = new PackageSession(package); var otherAssets = new List <AssetItem> { new AssetItem("asset11", new MyAsset11(), package), new AssetItem("asset12", new MyAsset12(), package), new AssetItem("asset13", new MyAsset13(), package), }; otherAssets.ForEach(x => package.Assets.Add(x)); var compileAssetReference = new MyAsset4 { CompileAssetReference = CreateRef <MyContent11>(otherAssets[0]), CompileContentReference = CreateRef <MyContent12>(otherAssets[1]), CompileRuntimeReference = CreateRef <MyContent13>(otherAssets[2]), }; var assetItem = new AssetItem("asset4", compileAssetReference, package); package.Assets.Add(assetItem); var asset = new MyAsset1 { CompileAssetReference = CreateRef <MyContent2>(assetItem) }; assetItem = new AssetItem("asset1", asset, package); package.Assets.Add(assetItem); package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location)); // Create context var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; // Builds the project Exception ex = null; MyAsset1Compiler.AssertFunc = (url, ass, pkg) => { AssertInThread(ref ex, () => Assert.AreEqual(1, TestCompilerBase.CompiledAssets.Count)); AssertInThread(ref ex, () => Assert.AreEqual(compileAssetReference.Id, TestCompilerBase.CompiledAssets.First().Id)); }; var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); var assetBuildResult = assetBuilder.Prepare(context); // Since MyAsset4 is a Runtime reference, it should be compiled, so we should have 2 asset (MyAsset1 and MyAsset4) to compile. Assert.AreEqual(2, assetBuildResult.BuildSteps.Count); var builder = new Builder(GlobalLogger.GetLogger("Test"), "", "", ""); builder.Root.Add(assetBuildResult.BuildSteps); builder.Run(Builder.Mode.Build, false); RethrowAssertsFromThread(ex); }
/// <inheritdoc/> public IEnumerable <IReference> EnumerateCompileTimeDependencies(PackageSession session) { var reference = AttachedReferenceManager.GetAttachedReference(Skeleton); if (reference != null) { yield return(new AssetReference <Asset>(reference.Id, reference.Url)); } }
private static int Main(string[] args) { Console.WriteLine(@"Bootstrapping: " + args[0]); var xenkoDir = Environment.GetEnvironmentVariable("SiliconStudioXenkoDir"); var xenkoPkgPath = UPath.Combine(xenkoDir, new UFile("Xenko.xkpkg")); var session = PackageSession.Load(xenkoPkgPath); var generator = TemplateSampleGenerator.Default; var logger = new LoggerResult(); var parameters = new TemplateGeneratorParameters { Session = session.Session }; var outputPath = UPath.Combine(new UDirectory(xenkoDir), new UDirectory("samplesGenerated")); outputPath = UPath.Combine(outputPath, new UDirectory(args[0])); var xenkoTemplates = session.Session.Packages.First().Templates; parameters.Description = xenkoTemplates.First(x => x.Group.StartsWith("Samples") && x.Id == new Guid(args[1])); parameters.Name = args[0]; parameters.Namespace = args[0]; parameters.OutputDirectory = outputPath; parameters.Logger = logger; generator.Generate(parameters); var updaterTemplate = xenkoTemplates.First(x => x.FullPath.ToString().EndsWith("UpdatePlatforms.xktpl")); parameters.Description = updaterTemplate; var updater = UpdatePlatformsTemplateGenerator.Default; var gameSettingsAsset = session.Session.Packages.Last().GetGameSettingsAsset(); var renderingSettings = gameSettingsAsset.Get <RenderingSettings>(); var updateParams = new GameTemplateParameters { Common = parameters, ForcePlatformRegeneration = true, GraphicsProfile = renderingSettings.DefaultGraphicsProfile, IsHDR = false, Orientation = (DisplayOrientation)renderingSettings.DisplayOrientation, Platforms = AssetRegistry.SupportedPlatforms.ToList() }; updater.Generate(updateParams); Console.WriteLine(logger.ToText()); return(logger.HasErrors ? 1 : 0); }
public static bool Upgrade(PackageSession session, ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage, IList <PackageLoadingAssetFile> assetFiles) { var packageSharedProfile = dependentPackage.Profiles.FindSharedProfile(); // Only do something if there is a default scene defined if (packageSharedProfile != null && packageSharedProfile.Properties.ContainsKey(DefaultScene)) { var defaultScene = Get(packageSharedProfile.Properties, DefaultScene); var defaultGraphicsProfile = Get(packageSharedProfile.Properties, DefaultGraphicsProfile); // If available, use graphics profile from Windows platform foreach (var profile in dependentPackage.Profiles) { if (profile.Platform == PlatformType.Windows && profile.Properties.ContainsKey(DefaultGraphicsProfile)) { defaultGraphicsProfile = Get(profile.Properties, DefaultGraphicsProfile); } } // Create asset var gameSettingsAsset = new GameSettingsAsset { DefaultScene = AttachedReferenceManager.CreateSerializableVersion <Scene>(defaultScene.Id, defaultScene.Location) }; var renderingSettings = gameSettingsAsset.Get <RenderingSettings>(); renderingSettings.DisplayOrientation = (RequiredDisplayOrientation)Get(packageSharedProfile.Properties, DisplayOrientation); renderingSettings.ColorSpace = ColorSpace.Linear; renderingSettings.DefaultBackBufferWidth = Get(packageSharedProfile.Properties, BackBufferWidth); renderingSettings.DefaultBackBufferHeight = Get(packageSharedProfile.Properties, BackBufferHeight); renderingSettings.DefaultGraphicsProfile = defaultGraphicsProfile; // Add asset using (var memoryStream = new MemoryStream()) { AssetSerializer.Save(memoryStream, gameSettingsAsset, log); assetFiles.Add(new PackageLoadingAssetFile(dependentPackage, GameSettingsLocation + FileExtension, null) { AssetContent = memoryStream.ToArray() }); } // Clean properties foreach (var profile in dependentPackage.Profiles) { profile.Properties.Remove(DefaultScene.Name); profile.Properties.Remove(BackBufferWidth.Name); profile.Properties.Remove(BackBufferHeight.Name); profile.Properties.Remove(DefaultGraphicsProfile.Name); profile.Properties.Remove(DisplayOrientation.Name); } } return(true); }
public void TestCompileAsset() { var package = new Package(); // ReSharper disable once UnusedVariable - we need a package session to compile var packageSession = new PackageSession(package); var otherAssets = new List <AssetItem> { new AssetItem("asset5", new MyAsset5(), package), new AssetItem("asset6", new MyAsset6(), package), new AssetItem("asset7", new MyAsset7(), package), }; otherAssets.ForEach(x => package.Assets.Add(x)); var compileAssetReference = new MyAsset2 { CompileAssetReference = CreateRef <MyContent5>(otherAssets[0]), CompileContentReference = CreateRef <MyContent6>(otherAssets[1]), CompileRuntimeReference = CreateRef <MyContent7>(otherAssets[2]), }; var assetItem = new AssetItem("asset2", compileAssetReference, package); package.Assets.Add(assetItem); var asset = new MyAsset1 { CompileAssetReference = CreateRef <MyContent2>(assetItem) }; assetItem = new AssetItem("asset1", asset, package); package.Assets.Add(assetItem); package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location)); // Create context var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; // Builds the project Exception ex = null; MyAsset1Compiler.AssertFunc = (url, ass, pkg) => { // Nothing must have been compiled before AssertInThread(ref ex, () => Assert.Empty(TestCompilerBase.CompiledAssets)); }; var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); var assetBuildResult = assetBuilder.Prepare(context); // Since MyAsset2 is a CompileAsset reference, it should not be compiled, so we should have only 1 asset (MyAsset1) to compile. Assert.Equal(1, assetBuildResult.BuildSteps.Count); var builder = new Builder(GlobalLogger.GetLogger("Test"), "", ""); builder.Root.Add(assetBuildResult.BuildSteps); builder.Run(Builder.Mode.Build, false); RethrowAssertsFromThread(ex); }
public async Task <LoggerResult> SaveProject() { if (PackageSession == null) { throw new InvalidOperationException("Cannot save the project before it was loaded."); } // TODO: check asset consistency // TODO: read more about Stride.Core.Assets.Editor.PackageViewModel //// Prepare packages to be saved by setting their dirty flag correctly //foreach (var package in LocalPackages) //{ // package.PreparePackageForSaving(); //} var viewUpdater = Services.GetService <IViewUpdater>(); PackageSessionResult sessionResult = await SetupResultProgress(viewUpdater, SaveProjectScope); // TODO: display a dialog with save progress // Force PackageSession.Save to be executed on the thread pool // otherwise it would block execution and we want this process to be async using (var scope = new TimedScope(SaveProjectScope, TimedScope.Status.Success)) { await Task.Run(() => { try { var saveParameters = PackageSaveParameters.Default(); // TODO: read more about Stride.Core.Assets.Editor.AssetViewModel // AllAssets.ForEach(x => x.PrepareSave(sessionResult)); PackageSession.Save(sessionResult, saveParameters); } catch (Exception e) { sessionResult.Error(string.Format("There was a problem saving the solution. {0}", e.Message), e); scope.Result = TimedScope.Status.Failure; } }); if (sessionResult.HasErrors) { scope.Result = TimedScope.Status.Failure; } } EditorViewModel.LoadingStatus = null; await viewUpdater.UpdateView(); ProjectSaved?.Invoke(sessionResult); return(sessionResult); }
/// <summary> /// Initializes a new instance of the <see cref="PackageSessionAnalysis" /> class. /// </summary> /// <param name="packageSession">The package session.</param> /// <param name="parameters">The parameters.</param> public PackageSessionAnalysis(PackageSession packageSession, PackageAnalysisParameters parameters) : base(packageSession) { if (parameters == null) { throw new ArgumentNullException("parameters"); } this.parameters = (PackageAnalysisParameters)parameters.Clone(); this.parameters.IsPackageCheckDependencies = true; }
public void TestWithPackage() { var inputs = new List <AssetItem>(); var asset = new AssetObjectTest(); var package = new Package(); package.Assets.Add(new AssetItem("0", asset)); var session = new PackageSession(package); for (int i = 0; i < 10; i++) { var newAsset = new AssetObjectTest() { Id = asset.Id, Reference = new AssetReference(asset.Id, "bad") }; inputs.Add(new AssetItem("0", newAsset)); } // Tries to use existing ids var outputs = new List <AssetItem>(); AssetCollision.Clean(null, inputs, outputs, AssetResolver.FromPackage(package), true, false); // Make sure we are generating exactly the same number of elements Assert.Equal(inputs.Count, outputs.Count); // Make sure that asset has been cloned Assert.NotEqual(inputs[0], outputs[0]); // First Id should not change Assert.NotEqual(inputs[0].Id, outputs[0].Id); // Make sure that all ids are different var ids = new HashSet <AssetId>(outputs.Select(item => item.Id)); Assert.Equal(inputs.Count, ids.Count); // Make sure that all locations are different var locations = new HashSet <UFile>(outputs.Select(item => item.Location)); Assert.Equal(inputs.Count, locations.Count); // Reference location "bad"should be fixed to "0_1" pointing to the first element foreach (var output in outputs) { // Make sure of none of the locations are using "0" Assert.NotEqual((UFile)"0", output.Location); var assetRef = ((AssetObjectTest)output.Asset).Reference; Assert.Equal("0 (2)", assetRef.Location); Assert.Equal(outputs[0].Id, assetRef.Id); } }
public PackageAssetTemplatingAnalysis(Package package, ILogger log) { if (package == null) throw new ArgumentNullException(nameof(package)); if (log == null) throw new ArgumentNullException(nameof(log)); assetsToProcess = new Dictionary<Guid, AssetItem>(); assetsProcessed = new Dictionary<Guid, AssetItem>(); this.package = package; session = package.Session; this.log = log; }
static void Main() { var clock = Stopwatch.StartNew(); for (int i = 0; i < 10; i++) { var session = PackageSession.Load(@"E:\Code\SengokuRun\SengokuRun\WindowsLauncher\GameAssets\Assets.xkpkg"); } var elapsed = clock.ElapsedMilliseconds; Console.WriteLine("{0}ms", elapsed); }
public IEnumerable <IReference> EnumerateCompileTimeDependencies(PackageSession session) { if (Prefab != null) { // Return the prefab itself yield return(Prefab); // Then we need to return used models and materials because they affects how the meshes are generated var prefab = session.FindAsset(Prefab.Location)?.Asset as PrefabAsset; if (prefab != null) { // Use a dictionary to ensure each reference is yielded only once var references = new Dictionary <Guid, IReference>(); foreach (var entity in prefab.Hierarchy.Parts) { // Gather all entities with a model component and a valid model var modelComponent = entity.Entity.Get <ModelComponent>(); if (modelComponent?.Model != null) { var modelReference = AttachedReferenceManager.GetAttachedReference(modelComponent.Model); var model = session.FindAsset(modelReference.Url)?.Asset as IModelAsset; if (model != null) { // Build the list of material for this model var materialList = model.Materials.Select(x => x.MaterialInstance.Material).ToList(); for (var i = 0; i < modelComponent.Materials.Count && i < materialList.Count; i++) { // Apply any material override from the model component var material = modelComponent.Materials[i]; if (material != null) { materialList[i] = material; } } // Add the model and the related materials to the list of reference references[modelReference.Id] = modelReference; foreach (var material in materialList) { var materialReference = AttachedReferenceManager.GetAttachedReference(material); references[materialReference.Id] = materialReference; } } } } // Finally return all the referenced models and materials foreach (var reference in references.Values) { yield return(reference); } } } }
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 override bool UpgradeBeforeAssembliesLoaded(PackageSession session, ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage) { if (dependency.Version.MinVersion < new PackageVersion("1.4.0-alpha01")) { UpgradeCode(dependentPackage, log, new RenameToXenkoCodeUpgrader()); } else if (dependency.Version.MinVersion < new PackageVersion("1.6.0-beta")) { UpgradeCode(dependentPackage, log, new NewComponentsCodeUpgrader()); } return(true); }
/// <summary> /// Finds all the template descriptions. /// </summary> /// <param name="session">The session for which to find template descriptions.</param> /// <returns>An enumeration of all the registered template descriptions.</returns> public static IEnumerable <TemplateDescription> FindTemplates(PackageSession session = null) { var packages = session?.Packages .Concat(ExtraPackages) .Distinct(DistinctPackagePathComparer.Default) ?? ExtraPackages; // TODO: This will not work if the same package has different versions return(packages.SelectMany(package => package.Templates) .OrderBy(template => template.Order) .ThenBy(template => template.Name) .ToList()); }
public AssetSourceTrackerViewModel(IViewModelServiceProvider serviceProvider, PackageSession packageSession, SessionViewModel session) : base(serviceProvider) { this.session = packageSession; sessionViewModel = session; UpdateSelectedAssetsFromSourceCommand = new AnonymousTaskCommand(ServiceProvider, UpdateSelectedAssetsFromSource); UpdateAllAssetsWithModifiedSourceCommand = new AnonymousTaskCommand(ServiceProvider, UpdateAllAssetsWithModifiedSource) { IsEnabled = false }; // This task will listen to the AssetSourceTracker for source file change notifications and collect them Dispatcher.InvokeTask(PullSourceFileChanges); }
private static void CompileSample(LoggerResult logger, string sampleName, PackageSession session) { var project = session.Projects.OfType <SolutionProject>().First(x => x.Platform == Core.PlatformType.Windows); var buildResult = VSProjectHelper.CompileProjectAssemblyAsync(null, project.FullPath, logger, extraProperties: new Dictionary <string, string> { { "StrideAutoTesting", "true" } }).BuildTask.Result; if (logger.HasErrors) { throw new InvalidOperationException($"Error compiling sample {sampleName}:\r\n{logger.ToText()}"); } }
public void TestPackageLoadingWithAssets() { var basePath = Path.Combine(DirectoryTestBase, @"TestPackage"); var projectPath = Path.Combine(basePath, "TestPackageLoadingWithAssets.pdxpkg"); var sessionResult = PackageSession.Load(projectPath); AssertResult(sessionResult); var session = sessionResult.Session; var rootPackageId = new Guid("4102BF96-796D-4800-9983-9C227FAB7BBD"); var project = session.Packages.Find(rootPackageId); Assert.IsNotNull(project); Assert.AreEqual(3, project.Assets.Count, "Invalid number of assets loaded"); Assert.AreEqual(1, project.LocalDependencies.Count, "Expecting subproject"); Assert.AreNotEqual(Guid.Empty, project.Assets.First().Id); // Check for UPathRelativeTo var profile = project.Profiles.FirstOrDefault(); Assert.NotNull(profile); var folder = profile.AssetFolders.FirstOrDefault(); Assert.NotNull(folder); Assert.NotNull(folder.Path); Assert.NotNull(folder.Path.IsAbsolute); var import = folder.RawImports.FirstOrDefault(); Assert.NotNull(import); Assert.IsTrue(import.SourceDirectory != null && import.SourceDirectory.IsRelative); // Save project back to disk on a different location project.FullPath = Path.Combine(DirectoryTestBase, @"TestPackage2\TestPackage2.pdxpkg"); var subPackage = session.Packages.Find(Guid.Parse("281321F0-7664-4523-B1DC-3CFC26F80F77")); subPackage.FullPath = Path.Combine(DirectoryTestBase, @"TestPackage2\SubPackage\SubPackage.pdxpkg"); session.Save(); var project2Result = PackageSession.Load(DirectoryTestBase + @"TestPackage2\TestPackage2.pdxpkg"); AssertResult(project2Result); var project2 = project2Result.Session.Packages.Find(rootPackageId); Assert.IsNotNull(project2); Assert.AreEqual(3, project2.Assets.Count); }
public void TestImportWithDuplicateWithinSameSession() { var name = "TestAssetImport"; var file = Path.Combine(Path.GetTempPath(), name + ".tmp"); const string fileContent = "This is the file content"; File.WriteAllText(file, fileContent); var fileHash = ObjectId.FromBytes(Encoding.UTF8.GetBytes(fileContent)); // Create a project with an asset reference a raw file var project = new Package(); using (var session = new PackageSession(project)) { var importSession = new AssetImportSession(session); // ------------------------------------------------------------------ // Step 1: Add files to session // ------------------------------------------------------------------ importSession.AddFile(file, project, UDirectory.Empty); // Simulate using another importer to duplicate the assets importSession.AddFile(file, new CustomImporter(), project, UDirectory.Empty); Assert.AreEqual(2, importSession.Imports[0].ByImporters.Count); // ------------------------------------------------------------------ // Step 2: Stage assets // ------------------------------------------------------------------ var stageResult = importSession.Stage(); //importSession.Imports[0].ByImporters[1].Items[0].SelectedItem = importSession.Imports[0].ByImporters[1].Items[0].Merges[0].PreviousItem; // Merge 0 into 1 importSession.Imports[0].ByImporters[0].Items[0].SelectedItem = importSession.Imports[0].ByImporters[0].Items[0].Merges[0].PreviousItem; // ------------------------------------------------------------------ // Step 4: Merge the asset specified by the previous step // ------------------------------------------------------------------ importSession.Merge(); Assert.IsTrue(stageResult); // ------------------------------------------------------------------ // Step 3: Import merged asset // ------------------------------------------------------------------ var result = importSession.Import(); Assert.AreEqual(3, project.Assets.Count); // TODO Add more tests } }
/// <summary> /// Initializes a new instance of the <see cref="AssetDependencyManager" /> class. /// </summary> /// <param name="session">The session.</param> /// <exception cref="System.ArgumentNullException">session</exception> internal AssetSourceTracker(PackageSession session) { if (session == null) { throw new ArgumentNullException(nameof(session)); } this.session = session; this.session.Packages.CollectionChanged += Packages_CollectionChanged; session.AssetDirtyChanged += Session_AssetDirtyChanged; Packages = new HashSet <Package>(); TrackingSleepTime = 100; tokenSourceForImportHash = new CancellationTokenSource(); threadWatcherEvent = new ManualResetEvent(false); }
/// <summary> /// Initializes a new instance of the <see cref="AssetDependencyManager" /> class. /// </summary> /// <param name="session">The session.</param> /// <exception cref="System.ArgumentNullException">session</exception> internal AssetDependencyManager(PackageSession session) { if (session == null) throw new ArgumentNullException(nameof(session)); this.session = session; this.session.Packages.CollectionChanged += Packages_CollectionChanged; session.AssetDirtyChanged += Session_AssetDirtyChanged; AssetsWithMissingReferences = new Dictionary<AssetId, AssetDependencies>(); MissingReferencesToParent = new Dictionary<AssetId, HashSet<AssetDependencies>>(); Packages = new HashSet<Package>(); Dependencies = new Dictionary<AssetId, AssetDependencies>(); // If the session has already a root package, then initialize the dependency manager directly if (session.LocalPackages.Any()) { Initialize(); } }
public override void Initialize() { base.Initialize(); TypeFactory = new TypeDescriptorFactory(); var assetDesc = TypeFactory.Find(typeof(TestAssetUpdate)); memberMyClass = assetDesc.Members.FirstOrDefault(member => member.Name == "MyClass"); if (session != null) { session.Dispose(); dependencyManager.Dispose(); } package = new Package(); session = new PackageSession(package); dependencyManager = new AssetDependencyManager(session); assetUpdater = new AssetUpdater(dependencyManager); }
/// <summary> /// Initializes a new instance of the <see cref="AssetDependencyManager" /> class. /// </summary> /// <param name="session">The session.</param> /// <exception cref="System.ArgumentNullException">session</exception> internal AssetDependencyManager(PackageSession session) { if (session == null) throw new ArgumentNullException("session"); this.session = session; this.session.Packages.CollectionChanged += Packages_CollectionChanged; session.AssetDirtyChanged += Session_AssetDirtyChanged; AssetsWithMissingReferences = new Dictionary<Guid, AssetDependencies>(); MissingReferencesToParent = new Dictionary<Guid, HashSet<AssetDependencies>>(); Packages = new HashSet<Package>(); Dependencies = new Dictionary<Guid, AssetDependencies>(); TrackingSleepTime = 100; tokenSourceForImportHash = new CancellationTokenSource(); threadWatcherEvent = new ManualResetEvent(false); // If the session has already a root package, then initialize the dependency manager directly if (session.LocalPackages.Any()) { Initialize(); } }
public void TestCachedAssetUpdate() { // ----------------------------------------------------------- // Change a property of A0 and see if the version of A0 returned by dependency computation from A1 is valid. // ----------------------------------------------------------- // 2 assets // A1 -- inherit from --> A0 // // ----------------------------------------------------------- var project = new Package(); var assets = new List<AssetObjectTest>(); var assetItems = new List<AssetItem>(); for (int i = 0; i < 2; ++i) { assets.Add(new AssetObjectTest()); assetItems.Add(new AssetItem("asset-" + i, assets[i])); project.Assets.Add(assetItems[i]); } assets[1].Base = new AssetBase(assets[0]); using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; assets[0].RawAsset = "tutu"; assetItems[0].IsDirty = true; var dependencies = dependencyManager.ComputeDependencies(assetItems[1]); var asset0 = dependencies.GetLinkOut(assetItems[0]); Assert.AreEqual(assets[0].RawAsset, ((AssetObjectTest)asset0.Item.Asset).RawAsset); } }
public void TestCompositionsInAndOut() { // ----------------------------------------------------------- // 3 assets // a1 : two parts // a2 (baseParts: a1, 2 instances -> 4 parts) // a3 (base: a2) // ----------------------------------------------------------- var package = new Package(); var assetItems = package.Assets; var a1 = new TestAssetWithParts(); a1.Parts.Add(new AssetPartTestItem(Guid.NewGuid())); a1.Parts.Add(new AssetPartTestItem(Guid.NewGuid())); assetItems.Add(new AssetItem("a1", a1)); var a2 = new TestAssetWithParts(); var aPartInstance1 = (TestAssetWithParts)a1.CreateChildAsset("a1"); var aPartInstance2 = (TestAssetWithParts)a1.CreateChildAsset("a1"); a2.AddPart(aPartInstance1); a2.AddPart(aPartInstance2); assetItems.Add(new AssetItem("a2", a2)); var a3 = a2.CreateChildAsset("a2"); assetItems.Add(new AssetItem("a3", a3)); // Create a session with this project using (var session = new PackageSession(package)) { var dependencyManager = session.DependencyManager; var deps = dependencyManager.FindDependencySet(aPartInstance1.Parts[0].Id); Assert.NotNull(deps); // The dependencies is the same as the a2 dependencies Assert.AreEqual(a2.Id, deps.Id); Assert.False(deps.HasMissingDependencies); Assert.AreEqual(1, deps.LinksIn.Count()); // a3 inherits from a2 Assert.AreEqual(1, deps.LinksOut.Count()); // a1 use composition inheritance from a1 var linkIn = deps.LinksIn.FirstOrDefault(); Assert.AreEqual(a3.Id, linkIn.Item.Id); Assert.AreEqual(ContentLinkType.Reference|ContentLinkType.Inheritance, linkIn.Type); var linkOut = deps.LinksOut.FirstOrDefault(); Assert.AreEqual(a1.Id, linkOut.Item.Id); Assert.AreEqual(ContentLinkType.CompositionInheritance, linkOut.Type); } }
public void TestCircularAndRecursiveDependencies() { // ----------------------------------------------------------- // Tests circular references and dependencies query // ----------------------------------------------------------- // 4 assets // [asset1] is referencing [asset2] // [asset2] is referencing [asset3] // [asset3] is referencing [asset4] // [asset4] is referencing [asset1] // We create a [project1] with [asset1, asset2, asset3, asset4] // Check direct input dependencies for [asset1]: [asset4] // Check all all input dependencies for [asset1]: [asset4, asset3, asset2, asset1] // Check direct output dependencies for [asset1]: [asset2] // Check all all output dependencies for [asset1]: [asset2, asset3, asset4, asset1] // ----------------------------------------------------------- var asset1 = new AssetObjectTest(); var asset2 = new AssetObjectTest(); var asset3 = new AssetObjectTest(); var asset4 = new AssetObjectTest(); var assetItem1 = new AssetItem("asset-1", asset1); var assetItem2 = new AssetItem("asset-2", asset2); var assetItem3 = new AssetItem("asset-3", asset3); var assetItem4 = new AssetItem("asset-4", asset4); asset1.Reference = new AssetReference<AssetObjectTest>(assetItem2.Id, assetItem2.Location); asset2.Reference = new AssetReference<AssetObjectTest>(assetItem3.Id, assetItem3.Location); asset3.Reference = new AssetReference<AssetObjectTest>(assetItem4.Id, assetItem4.Location); asset4.Reference = new AssetReference<AssetObjectTest>(assetItem1.Id, assetItem1.Location); var project = new Package(); project.Assets.Add(assetItem1); project.Assets.Add(assetItem2); project.Assets.Add(assetItem3); project.Assets.Add(assetItem4); // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; // Check internal states Assert.AreEqual(1, dependencyManager.Packages.Count); // only one project Assert.AreEqual(4, dependencyManager.Dependencies.Count); // asset1, asset2, asset3, asset4 Assert.AreEqual(0, dependencyManager.AssetsWithMissingReferences.Count); Assert.AreEqual(0, dependencyManager.MissingReferencesToParent.Count); // Check direct input references var dependenciesFirst = dependencyManager.Find(assetItem1); Assert.AreEqual(1, dependenciesFirst.LinksIn.Count()); var copyItem = dependenciesFirst.LinksIn.FirstOrDefault(); Assert.NotNull(copyItem.Element); Assert.AreEqual(assetItem4.Id, copyItem.Item.Id); // Check direct output references Assert.AreEqual(1, dependenciesFirst.LinksOut.Count()); copyItem = dependenciesFirst.LinksOut.FirstOrDefault(); Assert.NotNull(copyItem.Element); Assert.AreEqual(assetItem2.Id, copyItem.Item.Id); // Calculate full recursive references var dependencies = dependencyManager.ComputeDependencies(assetItem1); // Check all input references (recursive) var asset1RecursiveInputs = dependencies.LinksIn.OrderBy(item => item.Element.Location).ToList(); Assert.AreEqual(4, dependencies.LinksOut.Count()); Assert.AreEqual(assetItem1.Id, asset1RecursiveInputs[0].Item.Id); Assert.AreEqual(assetItem2.Id, asset1RecursiveInputs[1].Item.Id); Assert.AreEqual(assetItem3.Id, asset1RecursiveInputs[2].Item.Id); Assert.AreEqual(assetItem4.Id, asset1RecursiveInputs[3].Item.Id); // Check all output references (recursive) var asset1RecursiveOutputs = dependencies.LinksOut.OrderBy(item => item.Element.Location).ToList(); Assert.AreEqual(4, asset1RecursiveOutputs.Count); Assert.AreEqual(assetItem1.Id, asset1RecursiveInputs[0].Element.Id); Assert.AreEqual(assetItem2.Id, asset1RecursiveInputs[1].Element.Id); Assert.AreEqual(assetItem3.Id, asset1RecursiveInputs[2].Element.Id); Assert.AreEqual(assetItem4.Id, asset1RecursiveInputs[3].Element.Id); } }
public void TestInheritFrom() { // ----------------------------------------------------------- // Add dependencies of several types and check the InheritingFrom result // ----------------------------------------------------------- // 8 assets // A1 -- inherit from --> A0 // A2 -- inherit from --> A1 // A3 -- inherit from --> A2 // A8 -- inherit from --> A1 // A1 -- reference --> A5 // A4 -- reference --> A1 // A1 -- compose --> A7 // A2 -- compose --> A1 // A6 -- compose --> A1 // // Results expected on A1: // - Inherit: A2, A8 // - Composition: A2, A6 // - All: A2, A6, A8 // ----------------------------------------------------------- var project = new Package(); var assets = new List<AssetObjectTest>(); var assetItems = new List<AssetItem>(); for (int i = 0; i < 9; ++i) { assets.Add(new AssetObjectTest()); assetItems.Add(new AssetItem("asset-" + i, assets[i])); project.Assets.Add(assetItems[i]); } assets[1].Base = new AssetBase(assets[0]); assets[2].Base = new AssetBase(assets[1]); assets[3].Base = new AssetBase(assets[2]); assets[8].Base = new AssetBase(assets[1]); assets[1].Reference = CreateAssetReference(assetItems[5]); assets[4].Reference = CreateAssetReference(assetItems[1]); assets[1].BaseParts = new List<AssetBase>() { new AssetBase(assetItems[7].Location, assetItems[7].Asset) }; assets[2].BaseParts = new List<AssetBase>() { new AssetBase(assetItems[1].Location, assetItems[1].Asset) }; assets[6].BaseParts = new List<AssetBase>() { new AssetBase(assetItems[1].Location, assetItems[1].Asset) }; // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; var children = dependencyManager.FindAssetsInheritingFrom(assets[1].Id, AssetInheritanceSearchOptions.Base); Assert.AreEqual(2, children.Count); Assert.IsTrue(children.Any(x=>x.Id == assets[2].Id)); Assert.IsTrue(children.Any(x => x.Id == assets[8].Id)); var compositionChildren = dependencyManager.FindAssetsInheritingFrom(assets[1].Id, AssetInheritanceSearchOptions.Composition); Assert.AreEqual(2, compositionChildren.Count); Assert.IsTrue(compositionChildren.Any(x => x.Id == assets[2].Id)); Assert.IsTrue(compositionChildren.Any(x => x.Id == assets[6].Id)); var all = dependencyManager.FindAssetsInheritingFrom(assets[1].Id, AssetInheritanceSearchOptions.All); Assert.AreEqual(3, all.Count); Assert.IsTrue(all.Any(x => x.Id == assets[2].Id)); Assert.IsTrue(all.Any(x => x.Id == assets[6].Id)); Assert.IsTrue(all.Any(x => x.Id == assets[8].Id)); } }
public void TestLinkTypeProgressive() { // ----------------------------------------------------------- // Progressively add dependencies between elements and check the link types // ----------------------------------------------------------- // // 3 assets: // A1 -- inherit from --> A0 // A2 -- inherit from --> A1 // A1 -- compose --> A0 // A2 -- compose --> A1 // A1 -- reference --> A0 // A2 -- reference --> A1 // // --------------------------------------------------------- var project = new Package(); var assets = new List<AssetObjectTest>(); var assetItems = new List<AssetItem>(); for (int i = 0; i < 3; ++i) { assets.Add(new AssetObjectTest()); assetItems.Add(new AssetItem("asset-" + i, assets[i])); project.Assets.Add(assetItems[i]); } // Create a session with this project using (var session = new PackageSession(project)) { AssetDependencies dependencies; var dependencyManager = session.DependencyManager; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(0, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); assets[1].Reference = CreateAssetReference(assetItems[0]); assetItems[1].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkOut(assetItems[0]).Type); assets[2].Reference = CreateAssetReference(assetItems[1]); assetItems[2].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkOut(assetItems[0]).Type); assets[1].Base = new AssetBase(assets[0]); assetItems[1].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.Inheritance, dependencies.GetLinkOut(assetItems[0]).Type); assets[2].Base = new AssetBase(assets[1]); assetItems[2].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.Inheritance, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.Inheritance, dependencies.GetLinkOut(assetItems[0]).Type); assets[1].BaseParts = new List<AssetBase> { new AssetBase(assetItems[0].Location, assetItems[0].Asset) }; assetItems[1].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.Inheritance, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkOut(assetItems[0]).Type); assets[2].BaseParts = new List<AssetBase> { new AssetBase(assetItems[1].Location, assetItems[1].Asset) }; assetItems[2].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkOut(assetItems[0]).Type); project.Assets.Remove(assetItems[0]); dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(0, dependencies.LinksOut.Count()); Assert.AreEqual(1, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.All, dependencies.GetBrokenLinkOut(assetItems[0].Id).Type); project.Assets.Remove(assetItems[2]); dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(0, dependencies.LinksOut.Count()); Assert.AreEqual(1, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.All, dependencies.GetBrokenLinkOut(assetItems[0].Id).Type); project.Assets.Add(assetItems[0]); dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkOut(assetItems[0]).Type); project.Assets.Add(assetItems[2]); dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkOut(assetItems[0]).Type); assets[2].Base = null; assetItems[2].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.CompositionInheritance, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.All, dependencies.GetLinkOut(assetItems[0]).Type); assets[1].Base = null; assetItems[1].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.CompositionInheritance, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.CompositionInheritance, dependencies.GetLinkOut(assetItems[0]).Type); assets[2].BaseParts = null; assetItems[2].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.Reference | ContentLinkType.CompositionInheritance, dependencies.GetLinkOut(assetItems[0]).Type); assets[1].BaseParts = null; assetItems[1].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(1, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkOut(assetItems[0]).Type); assets[2].Reference = null; assetItems[2].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(1, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkOut(assetItems[0]).Type); assets[1].Reference = null; assetItems[1].IsDirty = true; dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(0, dependencies.LinksOut.Count()); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); } }
public void TestLinkType() { // ----------------------------------------------------------- // Add dependencies of several types and check the links // ----------------------------------------------------------- // 7 assets // A1 -- inherit from --> A0 // A2 -- inherit from --> A1 // A3 -- compose --> A1 // A1 -- compose --> A4 // A5 -- reference --> A1 // A1 -- reference --> A6 // // Expected links on A1: // - In: A2(Inheritance), A3(Composition), A5(Reference) // - Out: A0(Inheritance), A4(Composition), A6(Reference) // - BrokenOut: // // ------------------------------------ // Remove all items except A1 and check missing reference types // ----------------------------------------------------------- // // Expected broken out links // - BrokenOut: A0(Inheritance), A4(Composition), A6(Reference) // // --------------------------------------------------------- var project = new Package(); var assets = new List<AssetObjectTest>(); var assetItems = new List<AssetItem>(); for (int i = 0; i < 7; ++i) { assets.Add(new AssetObjectTest()); assetItems.Add(new AssetItem("asset-" + i, assets[i])); project.Assets.Add(assetItems[i]); } assets[1].Base = new AssetBase(assets[0]); assets[2].Base = new AssetBase(assets[1]); assets[3].BaseParts = new List<AssetBase>() { new AssetBase(assetItems[1].Location, assetItems[1].Asset) }; assets[1].BaseParts = new List<AssetBase>() { new AssetBase(assetItems[4].Location, assetItems[4].Asset) }; assets[5].Reference = CreateAssetReference(assetItems[1]); assets[1].Reference = CreateAssetReference(assetItems[6]); // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; var dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(3, dependencies.LinksIn.Count()); Assert.AreEqual(ContentLinkType.Inheritance | ContentLinkType.Reference, dependencies.GetLinkIn(assetItems[2]).Type); Assert.AreEqual(ContentLinkType.CompositionInheritance, dependencies.GetLinkIn(assetItems[3]).Type); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkIn(assetItems[5]).Type); Assert.AreEqual(3, dependencies.LinksOut.Count()); Assert.AreEqual(ContentLinkType.Inheritance | ContentLinkType.Reference, dependencies.GetLinkOut(assetItems[0]).Type); Assert.AreEqual(ContentLinkType.CompositionInheritance, dependencies.GetLinkOut(assetItems[4]).Type); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetLinkOut(assetItems[6]).Type); Assert.AreEqual(0, dependencies.BrokenLinksOut.Count()); var count = assets.Count; for (int i = 0; i < count; i++) { if (i != 1) project.Assets.Remove(assetItems[i]); } dependencies = dependencyManager.ComputeDependencies(assetItems[1]); Assert.AreEqual(0, dependencies.LinksIn.Count()); Assert.AreEqual(0, dependencies.LinksOut.Count()); Assert.AreEqual(3, dependencies.BrokenLinksOut.Count()); Assert.AreEqual(ContentLinkType.Inheritance | ContentLinkType.Reference, dependencies.GetBrokenLinkOut(assetItems[0].Id).Type); Assert.AreEqual(ContentLinkType.CompositionInheritance, dependencies.GetBrokenLinkOut(assetItems[4].Id).Type); Assert.AreEqual(ContentLinkType.Reference, dependencies.GetBrokenLinkOut(assetItems[6].Id).Type); } }
public void TestAssetChanged() { // ----------------------------------------------------------- // Case where an asset is changing is referencing // ----------------------------------------------------------- // 2 assets [asset1, asset2] // Change [asset1] referencing [asset2] // Notify the session to mark asset1 dirty // // ----------------------------------------------------------- var asset1 = new AssetObjectTest(); var asset2 = new AssetObjectTest(); var assetItem1 = new AssetItem("asset-1", asset1); var assetItem2 = new AssetItem("asset-2", asset2); var project = new Package(); project.Assets.Add(assetItem1); project.Assets.Add(assetItem2); // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; // Check internal states Assert.AreEqual(1, dependencyManager.Packages.Count); // only one project Assert.AreEqual(2, dependencyManager.Dependencies.Count); // asset1, asset2 Assert.AreEqual(0, dependencyManager.AssetsWithMissingReferences.Count); Assert.AreEqual(0, dependencyManager.MissingReferencesToParent.Count); asset1.Reference = new AssetReference<AssetObjectTest>(assetItem2.Id, assetItem2.Location); // Mark the asset dirty assetItem1.IsDirty = true; var dependencies1 = dependencyManager.FindDependencySet(asset1.Id); var copyItem = dependencies1.LinksOut.FirstOrDefault(); Assert.NotNull(copyItem.Element); Assert.AreEqual(assetItem2.Id, copyItem.Element.Id); var dependencies2 = dependencyManager.FindDependencySet(asset2.Id); copyItem = dependencies2.LinksIn.FirstOrDefault(); Assert.NotNull(copyItem.Element); Assert.AreEqual(assetItem1.Id, copyItem.Element.Id); } }
public void TestPackageAnalysis() { var package = new Package(); var baseAsset = new TestDiffAsset() { Name = "Red", Value = 1 }; var baseItem = new AssetItem("base", baseAsset); var childAsset = (TestDiffAsset)baseItem.CreateChildAsset(); var childItem = new AssetItem("child", childAsset); var newBaseAsset = (TestDiffAsset)AssetCloner.Clone(baseAsset); newBaseAsset.Name = "Green"; var newBaseItem = new AssetItem("base", newBaseAsset); package.Assets.Add(newBaseItem); package.Assets.Add(childItem); var session = new PackageSession(); session.Packages.Add(package); var result = new LoggerResult(); var analysis = new PackageAssetTemplatingAnalysis(package, result); analysis.Run(); Assert.False(result.HasErrors); var assetModified = (TestDiffAsset)package.Assets.Find("child").Asset; Assert.AreEqual("Green", assetModified.Name); }
/// <summary> /// Collects all references of an asset dynamically. /// </summary> /// <param name="result">The result.</param> /// <param name="packageSession">The package session.</param> /// <param name="isRecursive">if set to <c>true</c> [is recursive].</param> /// <param name="keepParents">Indicate if the parent of the provided <paramref name="result"/> should be kept or not</param> /// <exception cref="System.ArgumentNullException">packageSession</exception> private static void CollectDynamicOutReferences(AssetDependencies result, PackageSession packageSession, bool isRecursive, bool keepParents) { if (packageSession == null) throw new ArgumentNullException("packageSession"); CollectDynamicOutReferences(result, packageSession.FindAsset, isRecursive, keepParents); }
public void TestBasicPackageCreateSaveLoad() { var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad"; string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.pdxpkg"); string testGenerated2 = Path.Combine(dirPath,"TestPackage_TestBasicPackageCreateSaveLoad_Generated2.pdxpkg"); string referenceFilePath = Path.Combine(dirPath,"TestPackage_TestBasicPackageCreateSaveLoad_Reference.pdxpkg"); // 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 = session.Save(); Assert.IsFalse(result.HasErrors); // Reload the raw package and if UFile and UDirectory were saved relative var rawPackage = (Package)AssetSerializer.Load(testGenerated1); var rawPackageSharedProfile = rawPackage.Profiles.FirstOrDefault(); Assert.IsNotNull(rawPackageSharedProfile); var rawSourceFolder = rawPackage.Profiles.First().AssetFolders.FirstOrDefault(); Assert.IsNotNull(rawSourceFolder); Assert.AreEqual(".", (string)rawSourceFolder.Path); Assert.AreEqual("test.csproj", (string)rawPackageSharedProfile.ProjectReferences[0].Location); // Reload the package directly from the pdxpkg var project2Result = PackageSession.Load(testGenerated1); AssertResult(project2Result); var project2 = project2Result.Session.LocalPackages.FirstOrDefault(); Assert.IsNotNull(project2); Assert.AreEqual(project.Id, project2.Id); Assert.IsTrue(project2.Profiles.Count > 0); Assert.IsTrue(project2.Profiles.First().AssetFolders.Count > 0); var sourceFolder = project.Profiles.First().AssetFolders.First().Path; Assert.AreEqual(sourceFolder, project2.Profiles.First().AssetFolders.First().Path); // Reload the package from the sln var sessionResult = PackageSession.Load(session.SolutionPath); Assert.IsFalse(sessionResult.HasErrors); var sessionReload = sessionResult.Session; Assert.AreEqual(1, sessionReload.LocalPackages.Count()); Assert.AreEqual(project.Id, sessionReload.LocalPackages.First().Id); Assert.AreEqual(1, sessionReload.LocalPackages.First().Profiles.Count); var sharedProfileReload = sessionReload.LocalPackages.First().Profiles.First(); Assert.AreEqual(1, sharedProfileReload.ProjectReferences.Count); Assert.AreEqual(projectReference, sharedProfileReload.ProjectReferences[0]); }
public void TestAssetPart() { var project = new Package(); var assets = new List<TestAssetWithParts>(); var assetItems = new List<AssetItem>(); for (int i = 0; i < 2; ++i) { assets.Add(new TestAssetWithParts() { Parts = { new AssetPartTestItem(Guid.NewGuid()), new AssetPartTestItem(Guid.NewGuid()) } }); assetItems.Add(new AssetItem("asset-" + i, assets[i])); project.Assets.Add(assetItems[i]); } using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; // Check that part asset is accessible from the dependency manager var innerAssetId = assets[0].Parts[0].Id; var dependencySet = dependencyManager.FindDependencySet(innerAssetId); Assert.NotNull(dependencySet); // Check that dependencies are the same than container asset. var containerDependencySet = dependencyManager.FindDependencySet(assets[0].Id); Assert.AreEqual(containerDependencySet.Id, dependencySet.Id, "DependencySet must be the same for part and container"); // Check that inners are all there Assert.AreEqual(2, dependencySet.Parts.Count()); // Check that part asset is correctly stored into the dependencies AssetPart part; Assert.IsTrue(dependencySet.TryGetAssetPart(innerAssetId, out part)); Assert.AreEqual(assets[0].Parts[0].Id, part.Id); // Remove part asset assets[0].Parts.Clear(); assetItems[0].IsDirty = true; Assert.Null(dependencyManager.FindDependencySet(innerAssetId)); } }
public void TestMissingReferences() { // ----------------------------------------------------------- // Tests missing references // ----------------------------------------------------------- // 3 assets // [asset1] is referencing [asset2] // [asset3] is referencing [asset1] // Add asset1. Check dependencies // Add asset2. Check dependencies // Add asset3. Check dependencies // Remove asset1. Check dependencies // Add asset1. Check dependencies. // Modify reference asset3 to asset1 with fake asset. Check dependencies // Revert reference asset3 to asset1. Check dependencies // ----------------------------------------------------------- var asset1 = new AssetObjectTest(); var asset2 = new AssetObjectTest(); var asset3 = new AssetObjectTest(); var assetItem1 = new AssetItem("asset-1", asset1); var assetItem2 = new AssetItem("asset-2", asset2); var assetItem3 = new AssetItem("asset-3", asset3); asset1.Reference = new AssetReference<AssetObjectTest>(assetItem2.Id, assetItem2.Location); asset3.Reference = new AssetReference<AssetObjectTest>(assetItem1.Id, assetItem1.Location); var project = new Package(); // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; // Add asset1 project.Assets.Add(assetItem1); { var assets = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(1, assets.Count); Assert.AreEqual(asset1.Id, assets[0]); // Check dependencies on asset1 var dependencySetAsset1 = dependencyManager.FindDependencySet(asset1.Id); Assert.NotNull(dependencySetAsset1); Assert.AreEqual(0, dependencySetAsset1.LinksOut.Count()); Assert.IsTrue(dependencySetAsset1.HasMissingDependencies); Assert.AreEqual(asset2.Id, dependencySetAsset1.BrokenLinksOut.First().Element.Id); } // Add asset2 project.Assets.Add(assetItem2); { var assets = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(0, assets.Count); // Check dependencies on asset1 var dependencySetAsset1 = dependencyManager.FindDependencySet(asset1.Id); Assert.NotNull(dependencySetAsset1); Assert.AreEqual(1, dependencySetAsset1.LinksOut.Count()); Assert.AreEqual(0, dependencySetAsset1.LinksIn.Count()); Assert.AreEqual(asset2.Id, dependencySetAsset1.LinksOut.First().Element.Id); // Check dependencies on asset2 var dependencySetAsset2 = dependencyManager.FindDependencySet(asset2.Id); Assert.NotNull(dependencySetAsset2); Assert.AreEqual(0, dependencySetAsset2.LinksOut.Count()); Assert.AreEqual(1, dependencySetAsset2.LinksIn.Count()); Assert.AreEqual(asset1.Id, dependencySetAsset2.LinksIn.First().Element.Id); } // Add asset3 project.Assets.Add(assetItem3); Action checkAllOk = () => { var assets = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(0, assets.Count); // Check dependencies on asset1 var dependencySetAsset1 = dependencyManager.FindDependencySet(asset1.Id); Assert.NotNull(dependencySetAsset1); Assert.AreEqual(1, dependencySetAsset1.LinksOut.Count()); Assert.AreEqual(1, dependencySetAsset1.LinksIn.Count()); Assert.AreEqual(asset2.Id, dependencySetAsset1.LinksOut.First().Element.Id); Assert.AreEqual(asset3.Id, dependencySetAsset1.LinksIn.First().Element.Id); // Check dependencies on asset2 var dependencySetAsset2 = dependencyManager.FindDependencySet(asset2.Id); Assert.NotNull(dependencySetAsset2); Assert.AreEqual(0, dependencySetAsset2.LinksOut.Count()); Assert.AreEqual(1, dependencySetAsset2.LinksIn.Count()); Assert.AreEqual(asset1.Id, dependencySetAsset2.LinksIn.First().Element.Id); // Check dependencies on asset3 var dependencySetAsset3 = dependencyManager.FindDependencySet(asset3.Id); Assert.NotNull(dependencySetAsset3); Assert.AreEqual(1, dependencySetAsset3.LinksOut.Count()); Assert.AreEqual(0, dependencySetAsset3.LinksIn.Count()); Assert.AreEqual(asset1.Id, dependencySetAsset3.LinksOut.First().Element.Id); }; checkAllOk(); // Remove asset1 project.Assets.Remove(assetItem1); { var assets = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(1, assets.Count); Assert.AreEqual(asset3.Id, assets[0]); // Check dependencies on asset2 var dependencySetAsset2 = dependencyManager.FindDependencySet(asset2.Id); Assert.NotNull(dependencySetAsset2); Assert.AreEqual(0, dependencySetAsset2.LinksOut.Count()); Assert.AreEqual(0, dependencySetAsset2.LinksIn.Count()); // Check dependencies on asset3 var dependencySetAsset3 = dependencyManager.FindDependencySet(asset3.Id); Assert.NotNull(dependencySetAsset3); Assert.AreEqual(0, dependencySetAsset3.LinksOut.Count()); Assert.AreEqual(0, dependencySetAsset3.LinksIn.Count()); Assert.IsTrue(dependencySetAsset3.HasMissingDependencies); Assert.AreEqual(asset1.Id, dependencySetAsset3.BrokenLinksOut.First().Element.Id); } // Add asset1 project.Assets.Add(assetItem1); checkAllOk(); // Modify reference asset3 to asset1 with fake asset var previousAsset3ToAsset1Reference = asset3.Reference; asset3.Reference = new AssetReference<AssetObjectTest>(Guid.NewGuid(), "fake"); assetItem3.IsDirty = true; { var assets = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(1, assets.Count); Assert.AreEqual(asset3.Id, assets[0]); // Check dependencies on asset1 var dependencySetAsset1 = dependencyManager.FindDependencySet(asset1.Id); Assert.NotNull(dependencySetAsset1); Assert.AreEqual(1, dependencySetAsset1.LinksOut.Count()); Assert.AreEqual(0, dependencySetAsset1.LinksIn.Count()); Assert.AreEqual(asset2.Id, dependencySetAsset1.LinksOut.First().Element.Id); // Check dependencies on asset2 var dependencySetAsset2 = dependencyManager.FindDependencySet(asset2.Id); Assert.NotNull(dependencySetAsset2); Assert.AreEqual(0, dependencySetAsset2.LinksOut.Count()); Assert.AreEqual(1, dependencySetAsset2.LinksIn.Count()); Assert.AreEqual(asset1.Id, dependencySetAsset2.LinksIn.First().Element.Id); // Check dependencies on asset3 var dependencySetAsset3 = dependencyManager.FindDependencySet(asset3.Id); Assert.NotNull(dependencySetAsset3); Assert.AreEqual(0, dependencySetAsset3.LinksOut.Count()); Assert.AreEqual(0, dependencySetAsset3.LinksIn.Count()); Assert.IsTrue(dependencySetAsset3.HasMissingDependencies); Assert.AreEqual(asset3.Reference.Id, dependencySetAsset3.BrokenLinksOut.First().Element.Id); } // Revert back reference from asset3 to asset1 asset3.Reference = previousAsset3ToAsset1Reference; assetItem3.IsDirty = true; checkAllOk(); } }
public void TestTrackingPackageWithAssetsAndSave() { var dirPath = Path.Combine(Environment.CurrentDirectory, DirectoryTestBase + @"TestTracking"); TryDeleteDirectory(dirPath); string testGenerated1 = Path.Combine(dirPath, "TestTracking.xkpkg"); var project = new Package { FullPath = testGenerated1 }; project.Profiles.Add(new PackageProfile("Shared", new AssetFolder("."))); var asset1 = new AssetObjectTest(); var assetItem1 = new AssetItem("asset-1", asset1); project.Assets.Add(assetItem1); using (var session = new PackageSession(project)) { var dependencies = session.DependencyManager; dependencies.TrackingSleepTime = 10; dependencies.EnableTracking = true; // Save the session { var result = session.Save(); Assert.IsFalse(result.HasErrors); // Wait enough time for events Thread.Sleep(100); // Make sure that save is not generating events var events = dependencies.FindAssetFileChangedEvents().ToList(); Assert.AreEqual(0, events.Count); // Check tracked directories var directoriesTracked = dependencies.DirectoryWatcher.GetTrackedDirectories(); Assert.AreEqual(1, directoriesTracked.Count); Assert.AreEqual(dirPath.ToLowerInvariant(), directoriesTracked[0].ToLowerInvariant()); // Simulate multiple change an asset on the disk File.SetLastWriteTime(assetItem1.FullPath, DateTime.Now); Thread.Sleep(100); // Check that we are capturing this event events = dependencies.FindAssetFileChangedEvents().ToList(); Assert.AreEqual(1, events.Count); Assert.AreEqual(assetItem1.Location, events[0].AssetLocation); Assert.AreEqual(AssetFileChangedType.Updated, events[0].ChangeType); } // Save the project to another location { var dirPath2 = Path.Combine(Environment.CurrentDirectory, DirectoryTestBase + @"TestTracking2"); TryDeleteDirectory(dirPath2); string testGenerated2 = Path.Combine(dirPath2, "TestTracking.xkpkg"); project.FullPath = testGenerated2; var result = session.Save(); Assert.IsFalse(result.HasErrors); // Wait enough time for events Thread.Sleep(200); // Make sure that save is not generating events var events = dependencies.FindAssetFileChangedEvents().ToList(); Assert.AreEqual(0, events.Count); // Check tracked directories var directoriesTracked = dependencies.DirectoryWatcher.GetTrackedDirectories(); Assert.AreEqual(1, directoriesTracked.Count); Assert.AreEqual(dirPath2.ToLowerInvariant(), directoriesTracked[0].ToLowerInvariant()); } // Copy file to simulate a new file on the disk (we will not try to load it as it has the same guid { var fullPath = assetItem1.FullPath; var newPath = Path.Combine(Path.GetDirectoryName(fullPath), Path.GetFileNameWithoutExtension(fullPath) + "2" + Path.GetExtension(fullPath)); File.Copy(fullPath, newPath); // Wait enough time for events Thread.Sleep(200); // Make sure that save is not generating events var events = dependencies.FindAssetFileChangedEvents().ToList(); Assert.AreEqual(1, events.Count); Assert.IsTrue((events[0].ChangeType & AssetFileChangedType.Added) != 0); } } }
public void TestImportSessionSimple() { var name = "TestAssetImport"; var file = Path.Combine(Path.GetTempPath(), name + ".tmp"); const string fileContent = "This is the file content"; File.WriteAllText(file, fileContent); var fileHash = ObjectId.FromBytes(Encoding.UTF8.GetBytes(fileContent)); // Create a project with an asset reference a raw file var project = new Package(); using (var session = new PackageSession(project)) { var importSession = new AssetImportSession(session); // ------------------------------------------------------------------ // Step 1: Add files to session // ------------------------------------------------------------------ importSession.AddFile(file, project, UDirectory.Empty); // ------------------------------------------------------------------ // Step 2: Stage assets // ------------------------------------------------------------------ var stageResult = importSession.Stage(); Assert.IsTrue(stageResult); Assert.AreEqual(0, project.Assets.Count); // ------------------------------------------------------------------ // Step 3: Import asset directly (we don't try to merge) // ------------------------------------------------------------------ importSession.Import(); Assert.AreEqual(2, project.Assets.Count); var assetItem = project.Assets.FirstOrDefault(item => item.Asset is AssetImport); Assert.NotNull(assetItem); var importedAsset = (AssetImport)assetItem.Asset; Assert.IsInstanceOf<AssetImport>(importedAsset.Base.Asset); Assert.AreEqual((string)AssetBase.DefaultImportBase, importedAsset.Base.Location); // ------------------------------------------------------------------ // Reset the import session // ------------------------------------------------------------------ importSession.Reset(); // Get the list of asset already in the project var ids = project.Assets.Select(item => item.Id).ToList(); ids.Sort(); // ------------------------------------------------------------------ // Step 1: Add same file to the session // ------------------------------------------------------------------ importSession.AddFile(file, project, UDirectory.Empty); // ------------------------------------------------------------------ // Step 2: Stage assets // ------------------------------------------------------------------ stageResult = importSession.Stage(); // Select the previous item so that we will perform a merge foreach (var fileToImport in importSession.Imports) { foreach (var import in fileToImport.ByImporters) { foreach (var assetImportMergeGroup in import.Items) { Assert.AreEqual(1, assetImportMergeGroup.Merges.Count); // Check that we are matching correctly a previously imported asset var previousItem = assetImportMergeGroup.Merges[0].PreviousItem; Assert.IsTrue(project.Assets.ContainsById(previousItem.Id)); // Select the previous asset assetImportMergeGroup.SelectedItem = previousItem; } } } // ------------------------------------------------------------------ // Step 3: Merge the asset specified by the previous step // ------------------------------------------------------------------ importSession.Merge(); Assert.IsTrue(stageResult); Assert.AreEqual(2, project.Assets.Count); // ------------------------------------------------------------------ // Step 4: Import merged asset // ------------------------------------------------------------------ importSession.Import(); Assert.AreEqual(2, project.Assets.Count); // Get the list of asset already in the project var newIds = project.Assets.Select(item => item.Id).ToList(); newIds.Sort(); // Check that we have exactly the same number of assets Assert.AreEqual(ids, newIds); // Check that new AssetObjectTestRaw.Value is setup to the new value (1, was previously 0) var assetRaw = project.Assets.Select(item => item.Asset).OfType<AssetObjectTestSub>().FirstOrDefault(); Assert.IsNotNull(assetRaw); Assert.IsNotNull(assetRaw.Base); Assert.IsInstanceOf<AssetObjectTestSub>(assetRaw.Base.Asset); var assetRawBase = (AssetObjectTestSub)assetRaw.Base.Asset; Assert.AreEqual(1, assetRaw.Value); Assert.AreEqual(1, assetRawBase.Value); } }
/// <summary> /// Initializes a new instance of the <see cref="PackageSessionAnalysis" /> class. /// </summary> /// <param name="packageSession">The package session.</param> /// <exception cref="System.ArgumentNullException">packageSession</exception> protected PackageSessionAnalysisBase(PackageSession packageSession) { if (packageSession == null) throw new ArgumentNullException("packageSession"); this.packageSession = packageSession; }
public void TestFullSession() { // ----------------------------------------------------------- // This is a more complex test mixing several different cases: // ----------------------------------------------------------- // 4 assets // [asset1] is referencing [asset2] // [asset3] is referencing [asset4] // We create a [project1] with [asset1, asset2, asset3] // Start to evaluate the dependencies // Check the dependencies for this project, [asset4] is missing // We create a [project2] and add it to the session // We add [asset4] to the [project2] // All depedencies should be fine // Remove [project2] from session // Check the dependencies for this project, [asset4] is missing // ----------------------------------------------------------- var asset1 = new AssetObjectTest(); var asset2 = new AssetObjectTest(); var asset3 = new AssetObjectTest(); var asset4 = new AssetObjectTest(); var assetItem1 = new AssetItem("asset-1", asset1); var assetItem2 = new AssetItem("asset-2", asset2); var assetItem3 = new AssetItem("asset-3", asset3); var assetItem4 = new AssetItem("asset-4", asset4); asset1.Reference = new AssetReference<AssetObjectTest>(assetItem2.Id, assetItem2.Location); asset3.Reference = new AssetReference<AssetObjectTest>(assetItem4.Id, assetItem4.Location); var project = new Package(); project.Assets.Add(assetItem1); project.Assets.Add(assetItem2); project.Assets.Add(assetItem3); // Create a session with this project using (var session = new PackageSession(project)) { var dependencyManager = session.DependencyManager; // Check internal states Action checkState1 = () => { Assert.AreEqual(1, dependencyManager.Packages.Count); // only one project Assert.AreEqual(3, dependencyManager.Dependencies.Count); // asset1, asset2, asset3 Assert.AreEqual(1, dependencyManager.AssetsWithMissingReferences.Count); // asset3 => asset4 Assert.AreEqual(1, dependencyManager.MissingReferencesToParent.Count); // asset4 => [asset3] // Check missing references for asset3 => X asset4 var assetItemWithMissingReferences = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(1, assetItemWithMissingReferences.Count); Assert.AreEqual(assetItem3.Id, assetItemWithMissingReferences[0]); // Check missing reference var missingReferences = dependencyManager.FindMissingReferences(assetItem3).ToList(); Assert.AreEqual(1, missingReferences.Count); Assert.AreEqual(asset4.Id, missingReferences[0].Id); // Check references for: asset1 => asset2 var referencesFromAsset1 = dependencyManager.ComputeDependencies(assetItem1); Assert.AreEqual(1, referencesFromAsset1.LinksOut.Count()); var copyItem = referencesFromAsset1.LinksOut.FirstOrDefault(); Assert.NotNull(copyItem.Element); Assert.AreEqual(assetItem2.Id, copyItem.Element.Id); }; checkState1(); { // Add new project (must be tracked by the dependency manager) var project2 = new Package(); session.Packages.Add(project2); // Check internal states Assert.AreEqual(2, dependencyManager.Packages.Count); // Add missing asset4 project2.Assets.Add(assetItem4); var assetItemWithMissingReferences = dependencyManager.FindAssetsWithMissingReferences().ToList(); Assert.AreEqual(0, assetItemWithMissingReferences.Count); // Check internal states Assert.AreEqual(4, dependencyManager.Dependencies.Count); // asset1, asset2, asset3, asse4 Assert.AreEqual(0, dependencyManager.AssetsWithMissingReferences.Count); Assert.AreEqual(0, dependencyManager.MissingReferencesToParent.Count); // Try to remove the project and double check session.Packages.Remove(project2); checkState1(); } } }
/// <summary> /// Initializes a new instance of the <see cref="TemplateGeneratorContext"/> class. /// </summary> /// <param name="session">The session.</param> public TemplateGeneratorContext(PackageSession session) { if (session == null) throw new ArgumentNullException("session"); Session = session; }
/// <summary> /// Initializes a new instance of the <see cref="AssetBaseAnalysis"/> class. /// </summary> /// <param name="packageSession">The package session.</param> public AssetBaseAnalysis(PackageSession packageSession) : base(packageSession) { }