public void TestModelCreationFailureDoesntReturn() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var progressNotification = new ImportProgressNotification(); var zipStream = new MemoryStream(); using (var zip = ZipArchive.Create()) zip.SaveTo(zipStream, new ZipWriterOptions(CompressionType.Deflate)); var imported = await importer.Import( progressNotification, new ImportTask(zipStream, string.Empty) ); realm.Run(r => r.Refresh()); checkBeatmapSetCount(realm.Realm, 0); checkBeatmapCount(realm.Realm, 0); Assert.IsEmpty(imported); Assert.AreEqual(ProgressNotificationState.Cancelled, progressNotification.State); }); }
public void TestImportThenReimportAfterMissingFiles() { RunTestWithRealmAsync(async(realmFactory, storage) => { using var importer = new BeatmapModelManager(realmFactory, storage); using var store = new RealmRulesetStore(realmFactory, storage); var imported = await LoadOszIntoStore(importer, realmFactory.Realm); deleteBeatmapSet(imported, realmFactory.Realm); Assert.IsTrue(imported.DeletePending); // intentionally nuke all files storage.DeleteDirectory("files"); Assert.That(imported.Files.All(f => !storage.GetStorageForDirectory("files").Exists(f.File.GetStoragePath()))); var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Realm); // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash. Assert.IsTrue(imported.ID == importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID); Assert.IsFalse(imported.DeletePending); Assert.IsFalse(importedSecondTime.DeletePending); // check that the files now exist, even though they were deleted above. Assert.That(importedSecondTime.Files.All(f => storage.GetStorageForDirectory("files").Exists(f.File.GetStoragePath()))); }); }
public void TestRollbackOnFailure() { RunTestWithRealmAsync(async(realm, storage) => { int loggedExceptionCount = 0; Logger.NewEntry += l => { if (l.Target == LoggingTarget.Database && l.Exception != null) { Interlocked.Increment(ref loggedExceptionCount); } }; using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); realm.Realm.Write(() => imported.Hash += "-changed"); checkBeatmapSetCount(realm.Realm, 1); checkBeatmapCount(realm.Realm, 12); checkSingleReferencedFileCount(realm.Realm, 18); string?brokenTempFilename = TestResources.GetTestBeatmapForImport(); MemoryStream brokenOsu = new MemoryStream(); MemoryStream brokenOsz = new MemoryStream(await File.ReadAllBytesAsync(brokenTempFilename)); File.Delete(brokenTempFilename); using (var outStream = File.Open(brokenTempFilename, FileMode.CreateNew)) using (var zip = ZipArchive.Open(brokenOsz)) { zip.AddEntry("broken.osu", brokenOsu, false); zip.SaveTo(outStream, CompressionType.Deflate); } // this will trigger purging of the existing beatmap (online set id match) but should rollback due to broken osu. try { await importer.Import(new ImportTask(brokenTempFilename)); } catch { } EnsureLoaded(realm.Realm); checkBeatmapSetCount(realm.Realm, 1); checkBeatmapCount(realm.Realm, 12); checkSingleReferencedFileCount(realm.Realm, 18); Assert.AreEqual(1, loggedExceptionCount); File.Delete(brokenTempFilename); }); }
public void TestImportThenDeleteThenImportOptimisedPath() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); deleteBeatmapSet(imported, realm.Realm); Assert.IsTrue(imported.DeletePending); var originalAddedDate = imported.DateAdded; var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm); // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash. Assert.IsTrue(imported.ID == importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID); Assert.IsFalse(imported.DeletePending); Assert.IsFalse(importedSecondTime.DeletePending); Assert.That(importedSecondTime.DateAdded, Is.GreaterThan(originalAddedDate)); }); }
public void TestImportBeatmapThenCleanup() { RunTestWithRealmAsync(async(realm, storage) => { using (var importer = new BeatmapModelManager(realm, storage)) using (new RealmRulesetStore(realm, storage)) { Live <BeatmapSetInfo>?imported; using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream())) { imported = await importer.Import(reader); EnsureLoaded(realm.Realm); } Assert.AreEqual(1, realm.Realm.All <BeatmapSetInfo>().Count()); Assert.NotNull(imported); Debug.Assert(imported != null); imported.PerformWrite(s => s.DeletePending = true); Assert.AreEqual(1, realm.Realm.All <BeatmapSetInfo>().Count(s => s.DeletePending)); } }); Logger.Log("Running with no work to purge pending deletions"); RunTestWithRealm((realm, _) => { Assert.AreEqual(0, realm.Realm.All <BeatmapSetInfo>().Count()); }); }
public void TestImportThenDeleteFromStream() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?tempPath = TestResources.GetTestBeatmapForImport(); Live <BeatmapSetInfo>?importedSet; using (var stream = File.OpenRead(tempPath)) { importedSet = await importer.Import(new ImportTask(stream, Path.GetFileName(tempPath))); EnsureLoaded(realm.Realm); } Assert.NotNull(importedSet); Debug.Assert(importedSet != null); Assert.IsTrue(File.Exists(tempPath), "Stream source file somehow went missing"); File.Delete(tempPath); var imported = realm.Realm.All <BeatmapSetInfo>().First(beatmapSet => beatmapSet.ID == importedSet.ID); deleteBeatmapSet(imported, realm.Realm); }); }
public void TestImportThenDeleteThenImportWithOnlineIDsMissing() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); realm.Realm.Write(() => { foreach (var b in imported.Beatmaps) { b.OnlineID = -1; } }); deleteBeatmapSet(imported, realm.Realm); var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm); // check the newly "imported" beatmap has been reimported due to mismatch (even though hashes matched) Assert.IsTrue(imported.ID != importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.Beatmaps.First().ID); }); }
public void TestImportWithDuplicateHashes() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); string extractedFolder = $"{temp}_extracted"; Directory.CreateDirectory(extractedFolder); try { using (var zip = ZipArchive.Open(temp)) zip.WriteToDirectory(extractedFolder); using (var zip = ZipArchive.Create()) { zip.AddAllFromDirectory(extractedFolder); zip.AddEntry("duplicate.osu", Directory.GetFiles(extractedFolder, "*.osu").First()); zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate)); } await importer.Import(temp); EnsureLoaded(realm.Realm); } finally { Directory.Delete(extractedFolder, true); } }); }
public void TestImportCorruptThenImport() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); var firstFile = imported.Files.First(); long originalLength; using (var stream = storage.GetStream(firstFile.File.GetStoragePath())) originalLength = stream.Length; using (var stream = storage.GetStream(firstFile.File.GetStoragePath(), FileAccess.Write, FileMode.Create)) stream.WriteByte(0); var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm); using (var stream = storage.GetStream(firstFile.File.GetStoragePath())) Assert.AreEqual(stream.Length, originalLength, "Corruption was not fixed on second import"); // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash. Assert.IsTrue(imported.ID == importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID); checkBeatmapSetCount(realm.Realm, 1); checkSingleReferencedFileCount(realm.Realm, 18); }); }
public void TestAddFileToAsyncImportedBeatmap() { RunTestWithRealm((realm, storage) => { BeatmapSetInfo?detachedSet = null; using (var importer = new BeatmapModelManager(realm, storage)) using (new RealmRulesetStore(realm, storage)) { Task.Run(async() => { Live <BeatmapSetInfo>?beatmapSet; using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream())) // ReSharper disable once AccessToDisposedClosure beatmapSet = await importer.Import(reader); Assert.NotNull(beatmapSet); Debug.Assert(beatmapSet != null); // Intentionally detach on async thread as to not trigger a refresh on the main thread. beatmapSet.PerformRead(s => detachedSet = s.Detach()); }).WaitSafely(); Debug.Assert(detachedSet != null); importer.AddFile(detachedSet, new MemoryStream(), "test"); } }); }
public void TestUpdateDetachedBeatmapSet() { RunTestWithRealmAsync(async(realm, storage) => { using (var importer = new BeatmapModelManager(realm, storage)) using (new RealmRulesetStore(realm, storage)) { Live <BeatmapSetInfo>?beatmapSet; using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream())) beatmapSet = await importer.Import(reader); Assert.NotNull(beatmapSet); Debug.Assert(beatmapSet != null); // Detach at the BeatmapInfo point, similar to what GetWorkingBeatmap does. BeatmapInfo?detachedBeatmap = null; beatmapSet.PerformRead(s => detachedBeatmap = s.Beatmaps.First().Detach()); BeatmapSetInfo?detachedBeatmapSet = detachedBeatmap?.BeatmapSet; Debug.Assert(detachedBeatmapSet != null); var newUser = new RealmUser { Username = "******", OnlineID = 2 }; detachedBeatmapSet.Beatmaps.First().Metadata.Artist = "New Artist"; detachedBeatmapSet.Beatmaps.First().Metadata.Author = newUser; Assert.AreNotEqual(detachedBeatmapSet.Status, BeatmapOnlineStatus.Ranked); detachedBeatmapSet.Status = BeatmapOnlineStatus.Ranked; beatmapSet.PerformWrite(s => { detachedBeatmapSet.CopyChangesToRealm(s); }); beatmapSet.PerformRead(s => { // Check above changes explicitly. Assert.AreEqual(BeatmapOnlineStatus.Ranked, s.Status); Assert.AreEqual("New Artist", s.Beatmaps.First().Metadata.Artist); Assert.AreEqual(newUser, s.Beatmaps.First().Metadata.Author); Assert.NotZero(s.Files.Count); // Check nothing was lost in the copy operation. Assert.AreEqual(s.Files.Count, detachedBeatmapSet.Files.Count); Assert.AreEqual(s.Files.Select(f => f.File).Count(), detachedBeatmapSet.Files.Select(f => f.File).Count()); Assert.AreEqual(s.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count); Assert.AreEqual(s.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count()); Assert.AreEqual(s.Metadata, detachedBeatmapSet.Metadata); }); } }); }
public void TestImportWhenClosed() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); await LoadOszIntoStore(importer, realm.Realm); }); }
public void TestImportThenDelete() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); deleteBeatmapSet(imported, realm.Realm); }); }
public void TestImportThenImportWithChangedHashedFile() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); string extractedFolder = $"{temp}_extracted"; Directory.CreateDirectory(extractedFolder); try { var imported = await LoadOszIntoStore(importer, realm.Realm); await createScoreForBeatmap(realm.Realm, imported.Beatmaps.First()); using (var zip = ZipArchive.Open(temp)) zip.WriteToDirectory(extractedFolder); // arbitrary write to hashed file // this triggers the special BeatmapManager.PreImport deletion/replacement flow. using (var sw = new FileInfo(Directory.GetFiles(extractedFolder, "*.osu").First()).AppendText()) await sw.WriteLineAsync("// changed"); using (var zip = ZipArchive.Create()) { zip.AddAllFromDirectory(extractedFolder); zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate)); } var importedSecondTime = await importer.Import(new ImportTask(temp)); EnsureLoaded(realm.Realm); // check the newly "imported" beatmap is not the original. Assert.NotNull(importedSecondTime); Debug.Assert(importedSecondTime != null); Assert.IsTrue(imported.ID != importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID)); } finally { Directory.Delete(extractedFolder, true); } }); }
public void TestImportWithIgnoredDirectoryInArchive() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); string extractedFolder = $"{temp}_extracted"; string dataFolder = Path.Combine(extractedFolder, "actual_data"); string resourceForkFolder = Path.Combine(extractedFolder, "__MACOSX"); string resourceForkFilePath = Path.Combine(resourceForkFolder, ".extracted"); Directory.CreateDirectory(dataFolder); Directory.CreateDirectory(resourceForkFolder); using (var resourceForkFile = File.CreateText(resourceForkFilePath)) { await resourceForkFile.WriteLineAsync("adding content so that it's not empty"); } try { using (var zip = ZipArchive.Open(temp)) zip.WriteToDirectory(dataFolder); using (var zip = ZipArchive.Create()) { zip.AddAllFromDirectory(extractedFolder); zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate)); } var imported = await importer.Import(new ImportTask(temp)); Assert.NotNull(imported); Debug.Assert(imported != null); EnsureLoaded(realm.Realm); Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("__MACOSX"))), "Files contain resource fork folder, which should be ignored"); Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("actual_data"))), "Files contain common subfolder"); } finally { Directory.Delete(extractedFolder, true); } }); }
public void TestImportWhenFileOpen() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); using (File.OpenRead(temp)) await importer.Import(temp); EnsureLoaded(realm.Realm); File.Delete(temp); Assert.IsFalse(File.Exists(temp), "We likely held a read lock on the file when we shouldn't"); }); }
public void TestAccessFileAfterImport() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); var beatmap = imported.Beatmaps.First(); var file = beatmap.File; Assert.NotNull(file); Assert.AreEqual(beatmap.Hash, file !.File.Hash); }); }
public void TestImportThenImportWithReZip() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); string extractedFolder = $"{temp}_extracted"; Directory.CreateDirectory(extractedFolder); try { var imported = await LoadOszIntoStore(importer, realm.Realm); string hashBefore = hashFile(temp); using (var zip = ZipArchive.Open(temp)) zip.WriteToDirectory(extractedFolder); using (var zip = ZipArchive.Create()) { zip.AddAllFromDirectory(extractedFolder); zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate)); } // zip files differ because different compression or encoder. Assert.AreNotEqual(hashBefore, hashFile(temp)); var importedSecondTime = await importer.Import(new ImportTask(temp)); EnsureLoaded(realm.Realm); Assert.NotNull(importedSecondTime); Debug.Assert(importedSecondTime != null); // but contents doesn't, so existing should still be used. Assert.IsTrue(imported.ID == importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.PerformRead(s => s.Beatmaps.First().ID)); } finally { Directory.Delete(extractedFolder, true); } }); }
public void TestImportThenImportWithDifferentFilename() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); string extractedFolder = $"{temp}_extracted"; Directory.CreateDirectory(extractedFolder); try { var imported = await LoadOszIntoStore(importer, realm.Realm); using (var zip = ZipArchive.Open(temp)) zip.WriteToDirectory(extractedFolder); // change filename var firstFile = new FileInfo(Directory.GetFiles(extractedFolder).First()); firstFile.MoveTo(Path.Combine(firstFile.DirectoryName.AsNonNull(), $"{firstFile.Name}-changed{firstFile.Extension}")); using (var zip = ZipArchive.Create()) { zip.AddAllFromDirectory(extractedFolder); zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate)); } var importedSecondTime = await importer.Import(new ImportTask(temp)); EnsureLoaded(realm.Realm); Assert.NotNull(importedSecondTime); Debug.Assert(importedSecondTime != null); // check the newly "imported" beatmap is not the original. Assert.IsTrue(imported.ID != importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID)); } finally { Directory.Delete(extractedFolder, true); } }); }
public void TestImportWithDuplicateBeatmapIDs() { RunTestWithRealm((realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var metadata = new BeatmapMetadata { Artist = "SomeArtist", Author = { Username = "******" } }; var ruleset = realm.Realm.All <RulesetInfo>().First(); var toImport = new BeatmapSetInfo { OnlineID = 1, Beatmaps = { new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata) { OnlineID = 2, }, new BeatmapInfo(ruleset, new BeatmapDifficulty(), metadata) { OnlineID = 2, Status = BeatmapOnlineStatus.Loved, } } }; var imported = importer.Import(toImport); realm.Run(r => r.Refresh()); Assert.NotNull(imported); Debug.Assert(imported != null); Assert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[0].OnlineID)); Assert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[1].OnlineID)); }); }
public void TestImportThenImport() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); var imported = await LoadOszIntoStore(importer, realm.Realm); var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm); // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash. Assert.IsTrue(imported.ID == importedSecondTime.ID); Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID); checkBeatmapSetCount(realm.Realm, 1); checkSingleReferencedFileCount(realm.Realm, 18); }); }
public void TestDetachBeatmapSet() { RunTestWithRealmAsync(async(realm, storage) => { using (var importer = new BeatmapModelManager(realm, storage)) using (new RealmRulesetStore(realm, storage)) { Live <BeatmapSetInfo>?beatmapSet; using (var reader = new ZipArchiveReader(TestResources.GetTestBeatmapStream())) beatmapSet = await importer.Import(reader); Assert.NotNull(beatmapSet); Debug.Assert(beatmapSet != null); BeatmapSetInfo?detachedBeatmapSet = null; beatmapSet.PerformRead(live => { detachedBeatmapSet = live.Detach(); // files are omitted Assert.AreEqual(0, detachedBeatmapSet.Files.Count); Assert.AreEqual(live.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count); Assert.AreEqual(live.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count()); Assert.AreEqual(live.Metadata, detachedBeatmapSet.Metadata); }); Debug.Assert(detachedBeatmapSet != null); // Check detached instances can all be accessed without throwing. Assert.AreEqual(0, detachedBeatmapSet.Files.Count); Assert.NotNull(detachedBeatmapSet.Beatmaps.Count); Assert.NotZero(detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count()); Assert.NotNull(detachedBeatmapSet.Metadata); // Check cyclic reference to beatmap set Assert.AreEqual(detachedBeatmapSet, detachedBeatmapSet.Beatmaps.First().BeatmapSet); } }); }
public void TestUpdateBeatmapInfo() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); await importer.Import(temp); // Update via the beatmap, not the beatmap info, to ensure correct linking BeatmapSetInfo setToUpdate = realm.Realm.All <BeatmapSetInfo>().First(); var beatmapToUpdate = setToUpdate.Beatmaps.First(); realm.Realm.Write(() => beatmapToUpdate.DifficultyName = "updated"); BeatmapInfo updatedInfo = realm.Realm.All <BeatmapInfo>().First(b => b.ID == beatmapToUpdate.ID); Assert.That(updatedInfo.DifficultyName, Is.EqualTo("updated")); }); }
public void TestImportNestedStructure() { RunTestWithRealmAsync(async(realm, storage) => { using var importer = new BeatmapModelManager(realm, storage); using var store = new RealmRulesetStore(realm, storage); string?temp = TestResources.GetTestBeatmapForImport(); string extractedFolder = $"{temp}_extracted"; string subfolder = Path.Combine(extractedFolder, "subfolder"); Directory.CreateDirectory(subfolder); try { using (var zip = ZipArchive.Open(temp)) zip.WriteToDirectory(subfolder); using (var zip = ZipArchive.Create()) { zip.AddAllFromDirectory(extractedFolder); zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate)); } var imported = await importer.Import(new ImportTask(temp)); Assert.NotNull(imported); Debug.Assert(imported != null); EnsureLoaded(realm.Realm); Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("subfolder"))), "Files contain common subfolder"); } finally { Directory.Delete(extractedFolder, true); } }); }
protected override BeatmapModelDownloader CreateBeatmapModelDownloader(BeatmapModelManager modelManager, IAPIProvider api, GameHost host) { return(new TestBeatmapModelDownloader(modelManager, api, host)); }
public TestBeatmapModelDownloader(BeatmapModelManager modelManager, IAPIProvider apiProvider, GameHost gameHost) : base(modelManager, apiProvider, gameHost) { }