public void CanSaveAndLoadNamesAndFormats() { var buffer = Enumerable.Repeat((byte)0xFF, 0x200).ToArray(); var model = new PokemonModel(buffer); var viewPort = new ViewPort("file.txt", model) { Width = 0x10, Height = 0x10 }; StoredMetadata metadata = null; var fileSystem = new StubFileSystem { Save = file => true, SaveMetadata = (file, md) => { metadata = new StoredMetadata(md); return(true); } }; viewPort.Edit("^bob\"\" \"Hello\""); viewPort.Save.Execute(fileSystem); var model2 = new PokemonModel(buffer, metadata); var viewPort2 = new ViewPort("file.txt", model) { Width = 0x10, Height = 0x10 }; Assert.Equal("bob", ((Anchor)viewPort2[0, 0].Format).Name); }
public UploadedFile(FileIdentifier id, IFileInfo fileInfo, StoredMetadata metadata) { this._fileInfo = fileInfo; this.Metadata = metadata; this.Id = id; }
public void MetadataCanLoadList() { var lines = new List <string>(); lines.Add("[[List]]"); lines.Add("Name = '''moveeffects'''"); lines.Add("1 = ["); lines.Add(" '''abc''',"); lines.Add(" '''\"def\"''',"); lines.Add("]"); lines.Add("5 = ['''xyz''']"); lines.Add("7 = '''bob'''"); var metadata = new StoredMetadata(lines.ToArray()); var moveEffects = metadata.Lists.Single(list => list.Name == "moveeffects"); Assert.Equal(8, moveEffects.Count); Assert.Equal("0", moveEffects[0]); Assert.Equal("abc", moveEffects[1]); Assert.Equal("\"def\"", moveEffects[2]); Assert.Equal("3", moveEffects[3]); Assert.Equal("4", moveEffects[4]); Assert.Equal("xyz", moveEffects[5]); Assert.Equal("6", moveEffects[6]); Assert.Equal("bob", moveEffects[7]); }
private async Task ReserveUploadAsync(UploadLinkModel model) { CancellationToken cancellationToken = this.HttpContext.RequestAborted; StoredMetadata metadata = new StoredMetadata { Expiration = model.Expiration, UploadedOn = DateTime.UtcNow, IsReservation = true, Sender = model.Sender }; // Ensure no empty contact information if (model.Sender != null && String.IsNullOrEmpty(model.Sender.Name) && String.IsNullOrEmpty(model.Sender.EmailAddress)) { metadata.Sender = null; } // Write away using (Stream fileStream = this._fileWriter.OpenWriteStream(this._fileStore.GetMetadataFile(model.FileIdentifier))) { using (StreamWriter sw = new StreamWriter(fileStream, Encoding.UTF8)) { await sw.WriteAsync(metadata.Serialize()).ConfigureAwait(false); await fileStream.FlushAsync(cancellationToken).ConfigureAwait(false); } } }
public void OffsetPointerOutOfRange_LoadMetadata_NoOffsetPointer() { var metadata = new StoredMetadata(offsetPointers: new[] { new StoredOffsetPointer(0x300, 1) }); Model.LoadMetadata(metadata); Assert.Equal(int.MaxValue, Model.GetNextRun(0).Start); }
public void OffsetPointerOutOfRange_InitMetadata_NoOffsetPointer() { var metadata = new StoredMetadata(offsetPointers: new[] { new StoredOffsetPointer(0x300, 1) }); var model = New.PokemonModel(Data, metadata, Singletons); Assert.Equal(int.MaxValue, model.GetNextRun(0).Start); }
private static AutoSearchModel LoadModelNoCache(string name) { Skip.IfNot(File.Exists(name)); var data = File.ReadAllBytes(name); var metadata = new StoredMetadata(new string[0]); var model = new AutoSearchModel(data, metadata); return(model); }
public void CanLoadVersionFromToml() { var file = @" [General] ApplicationVersion = '''0.1.0''' "; var metadata = new StoredMetadata(file.Split(Environment.NewLine)); Assert.Equal("0.1.0", metadata.Version); }
public void UnmappedPointerInMetadata_WriteAnchor_ModelUpdates() { var pointers = new[] { new StoredUnmappedPointer(0x20, "name") }; var metadata = new StoredMetadata(unmappedPointers: pointers); var model = new PokemonModel(new byte[0x200], metadata, Singletons); model.ObserveAnchorWritten(Token, "name", new NoInfoRun(0x80)); Assert.Equal(0x80, model.ReadPointer(0x20)); }
public void Metadata_Export_ContainsTableGroups() { var initialMetadata = new StoredMetadata(tableGroups: new[] { new TableGroup("group1", new[] { "table1" }) }); Model.Load(new byte[0x200], initialMetadata); var newMetadata = Model.ExportMetadata(Singletons.MetadataInfo); var text = newMetadata.Serialize(); Assert.Contains("[[TableGroup]]", text); }
public void UnmappedPointerInMetadata_Load_NullPointer() { var pointers = new [] { new StoredUnmappedPointer(0x20, "name") }; var metadata = new StoredMetadata(unmappedPointers: pointers); var model = new PokemonModel(new byte[0x200], metadata, Singletons); var run = model.GetNextRun(0x20); Assert.IsType <PointerRun>(run); Assert.Equal(0x20, run.Start); }
public void DefaultList_ChangeContent_HashDoesNotMatch() { var text = new List <string>(); BaseModel.GetDefaultMetadatas().First().Lists[0].AppendContents(text); var hashLine = text.Single(line => line.Trim().StartsWith("DefaultHash = '''")); text[text.IndexOf(hashLine)] = "DefaultHash = '''0'''"; var metadata = new StoredMetadata(text.ToArray()); Assert.False(metadata.Lists[0].HashMatches); }
public void NoGroups_UpdateVersion_Groups() { SetGameCode(HardcodeTablesModel.FireRed); var metadata = new StoredMetadata( anchors: new[] { new StoredAnchor(0x100, "anchor", string.Empty) }, generalInfo: New.EarliestVersionInfo ); var model = New.PokemonModel(Model.RawData, metadata, Singletons); var groups = model.ExportMetadata(Singletons.MetadataInfo).TableGroups; Assert.NotEmpty(groups); }
public void NewMetadata_Reopen_MetadataMatches(string romName) { Skip.IfNot(File.Exists(romName), "Test cannot run without a real rom"); var singletons = BaseViewModelTestClass.Singletons; var fileData = File.ReadAllBytes(romName); var code = fileData.GetGameCode(); var freshModel = new HardcodeTablesModel(singletons, fileData); var metadata1 = freshModel.ExportMetadata(singletons.MetadataInfo); var serializedBack = new StoredMetadata(metadata1.Serialize()); var reopenModel = new HardcodeTablesModel(singletons, fileData, serializedBack); var metadata2 = reopenModel.ExportMetadata(singletons.MetadataInfo); // verify that the content is the same Assert.Equal(metadata1.FreeSpaceBuffer, metadata2.FreeSpaceBuffer); // FreeSpaceSearch is allowed to be different Assert.Equal(metadata1.Version, metadata2.Version); Assert.Equal(metadata1.NextExportID, metadata2.NextExportID); foreach (var list in metadata2.Lists) { var originalList = metadata1.Lists.Single(freshList => freshList.Name == list.Name); Assert.Equal(originalList.Count, list.Count); Assert.All(originalList.Contents.Count.Range(), i => Assert.Equal(originalList.Contents[i], list.Contents[i])); } foreach (var matchedWord in metadata2.MatchedWords) { var originalMatchedWord = metadata1.MatchedWords.Single(freshMatchedWord => freshMatchedWord.Address == matchedWord.Address); Assert.Equal(originalMatchedWord.Name, matchedWord.Name); Assert.Equal(originalMatchedWord.AddOffset, matchedWord.AddOffset); Assert.Equal(originalMatchedWord.MultOffset, matchedWord.MultOffset); Assert.Equal(originalMatchedWord.Note, matchedWord.Note); } foreach (var namedAnchor in metadata2.NamedAnchors) { var originalNamedAnchor = metadata1.NamedAnchors.Single(anchor => anchor.Name == namedAnchor.Name); Assert.Equal(originalNamedAnchor.Address, namedAnchor.Address); Assert.Equal(originalNamedAnchor.Format, namedAnchor.Format); } foreach (var offsetPointer in metadata2.OffsetPointers) { var originalOffsetPointer = metadata1.OffsetPointers.Single(pointer => pointer.Address == offsetPointer.Address); Assert.Equal(originalOffsetPointer.Offset, offsetPointer.Offset); } }
public void Text_LoadMetadata_ContainsTableGroups() { var metadata = new StoredMetadata(new[] { "[[TableGroup]]", "Name = '''group1'''", "0 = [", " '''table1''',", " '''table2''',", "]", }); Assert.Single(metadata.TableGroups); Assert.Equal("group1", metadata.TableGroups[0].GroupName); Assert.Equal(new[] { "table1", "table2" }, metadata.TableGroups[0].Tables); }
public void Text_LoadMetadata_CaptureHash() { var text = @" [[TableGroup]] Name = '''custom''' DefaultHash = '''0''' 0 = [ '''table''', ] "; var metadata = new StoredMetadata(text.SplitLines()); Assert.Equal("0", metadata.TableGroups.Single().Hash); }
public void TableGroupWithEditedHash_UpdateVersion_DoNotAddGroupsWithSameTables() { SetGameCode(HardcodeTablesModel.FireRed); var metadata = new StoredMetadata( tableGroups: new[] { new TableGroup("custom", new[] { HardcodeTablesModel.PokemonNameTable }, "0") }, generalInfo: New.EarliestVersionInfo ); var model = New.PokemonModel(Model.RawData, metadata, Singletons); var groups = model.ExportMetadata(Singletons.MetadataInfo).TableGroups; var group = groups.Single(group => group.GroupName == "custom"); Assert.Single(group.Tables); Assert.Single(groups.Where(group => group.Tables.Contains(HardcodeTablesModel.PokemonNameTable))); }
public void CanSaveAndLoadNamesAndFormats() { SetFullModel(0xFF); var viewPort = ViewPort; StoredMetadata metadata = null; var fileSystem = new StubFileSystem { Save = file => true, SaveMetadata = (file, md) => { metadata = new StoredMetadata(md); return(true); } }; viewPort.Edit("^bob\"\" \"Hello\""); viewPort.Save.Execute(fileSystem); var model2 = new PokemonModel(Model.RawData, metadata); var viewPort2 = AutoSearchTests.NewViewPort("file.txt", model2); Assert.Equal("bob", ((Anchor)viewPort2[0, 0].Format).Name); }
public async Task <StoredMetadata?> GetMetadataAsync(IFileInfo file) { StoredMetadata metadata; try { string json; using (StreamReader sw = new StreamReader(file.CreateReadStream())) { json = await sw.ReadToEndAsync().ConfigureAwait(false); } metadata = StoredMetadata.Deserialize(json); } catch (Exception ex) { this._logger.LogError(LogEvents.UploadCorrupted, ex, "Metadata of upload at location {0} is corrupted", file.PhysicalPath); return(null); } return(metadata); }
public void CanSaveLooseWordRuns() { var fileSystem = new StubFileSystem(); string[] metadata = null; fileSystem.Save = file => true; fileSystem.SaveMetadata = (file, lines) => { metadata = lines; return(true); }; StandardSetup(out var data, out var model, out var viewPort); viewPort.Edit("::test "); viewPort.Save.Execute(fileSystem); var storedMetadata = new StoredMetadata(metadata); var matchedWord = storedMetadata.MatchedWords.First(); Assert.Equal(0, matchedWord.Address); Assert.Equal("test", matchedWord.Name); }
public void HashDoesNotMatch_UpdateVersion_ListDoesNotUpdate() { var someRealList = BaseModel.GetDefaultMetadatas().First().Lists.First(); SetGameCode("BPRE0"); var content = new[] { "some", "content" }; var metadata = new StoredMetadata( generalInfo: new StubMetadataInfo { VersionNumber = "0.0.1" }, lists: new[] { new StoredList(someRealList.Name, content, hash: "0") } ); var model = new PokemonModel(Model.RawData, metadata, Singletons); model.TryGetList(someRealList.Name, out var list); Assert.Equal(content, list.ToList()); }
private static void CheckIsNewerVersionAvailable(EditorViewModel viewModel) { if (DateTime.Now < viewModel.LastUpdateCheck + TimeSpan.FromDays(1)) { return; } viewModel.LastUpdateCheck = DateTime.Now; try { using (var client = new HttpClient()) { string content = client.GetStringAsync(ReleaseUrl).Result; var mostRecentVersion = content .Split('\n') .Where(line => line.Contains("/haven1433/HexManiacAdvance/tree/")) .Select(line => line.Split("title=").Last().Split('"')[1].Split('v').Last()) .First(); viewModel.IsNewVersionAvailable = StoredMetadata.NeedVersionUpdate(viewModel.Singletons.MetadataInfo.VersionNumber, mostRecentVersion); } } catch { // Exceptions are expected on Windows 7. // If anything goes wrong, we probably don't care. It just means that the IsNewVersionAvailable will be false. } }
private async Task StoreMetadataAsync(FileIdentifier id, StoredMetadata metadata, CancellationToken cancellationToken) { IFileInfo metadataFile = this._fileStore.GetMetadataFile(id); if (metadata.IsReservation) { StoredMetadata?originalStoredMetadata = await this._metadataReader.GetMetadataAsync(metadataFile); if (originalStoredMetadata == null) { this._logger.LogWarning(LogEvents.UploadFailed, "{0}: Metadata file expected for reservation at {1}", id, metadataFile.PhysicalPath); throw new UploadFailedException("Missing metadata for reserved upload"); } // Sync critical metadata metadata.Expiration = originalStoredMetadata.Expiration; metadata.Sender = originalStoredMetadata.Sender; // Delete metadata so it can be recreated again this._fileWriter.Delete(metadataFile); } else { // Correct the timestamp with the upload time TimeSpan diff = DateTime.UtcNow - this.GetProgressObject(id).StartTime; metadata.Expiration += diff; } // Write away using (Stream fileStream = this._fileWriter.OpenWriteStream(metadataFile)) { using (StreamWriter sw = new StreamWriter(fileStream, Encoding.UTF8)) { await sw.WriteAsync(metadata.Serialize()).ConfigureAwait(false); await fileStream.FlushAsync(cancellationToken).ConfigureAwait(false); } } }
public void Groups_UpdateVersion_NoDuplicates() { // calculate 'default' TableGroups SetGameCode(HardcodeTablesModel.FireRed); var model = New.HardcodeTablesModel(Singletons, Model.RawData); var metadata = model.ExportMetadata(Singletons.MetadataInfo); var tableGroups = metadata.TableGroups; // upgrade version metadata = new StoredMetadata( tableGroups: tableGroups, generalInfo: New.EarliestVersionInfo); model = New.PokemonModel(model.RawData, metadata, Singletons); var newGroups = model.ExportMetadata(Singletons.MetadataInfo).TableGroups; Assert.Equal(tableGroups.Count, newGroups.Count); for (int i = 0; i < newGroups.Count; i++) { Assert.Equal(tableGroups[i].GroupName, newGroups[i].GroupName); Assert.Equal(tableGroups[i].Hash, newGroups[i].Hash); } }
public Task DeleteAsync(string name, string config, string credentialsJson) { StoredMetadata.Remove(name); return(Task.CompletedTask); }
public void OldMetadata_Upgrade_MetadataMatchesNewLoad(string romName, string tomlName) { Skip.IfNot(File.Exists(romName), "Test cannot run without a real rom"); var singletons = BaseViewModelTestClass.Singletons; var tomlPath = "../../../../src/HexManiac.Tests/toml_versions/"; var fileData = File.ReadAllBytes(romName); var code = fileData.GetGameCode(); tomlPath += code + tomlName; var oldMetadata = new StoredMetadata(File.ReadAllLines(tomlPath)); var upgradedModel = new HardcodeTablesModel(singletons, fileData, oldMetadata); var freshModel = new HardcodeTablesModel(singletons, fileData, new StoredMetadata(new string[0])); var upgradedMetadata = upgradedModel.ExportMetadata(singletons.MetadataInfo); var freshMetadata = freshModel.ExportMetadata(singletons.MetadataInfo); // verify that the content is the same Assert.Equal(upgradedMetadata.FreeSpaceBuffer, freshMetadata.FreeSpaceBuffer); // FreeSpaceSearch is allowed to be different Assert.Equal(upgradedMetadata.Version, freshMetadata.Version); Assert.Equal(upgradedMetadata.NextExportID, freshMetadata.NextExportID); // there may be some old non-deleted lists in upgradedMetadata. That's ok. // but for every list in the fresh metadata, make sure the upgraded metadata has it. foreach (var list in freshMetadata.Lists) { var updateList = upgradedMetadata.Lists.Single(updatedList => updatedList.Name == list.Name); Assert.Equal(list.Count, updateList.Count); Assert.All(updateList.Contents.Count.Range(), i => Assert.Equal(list.Contents[i], updateList.Contents[i])); } foreach (var matchedWord in upgradedMetadata.MatchedWords) { var newMatchedWord = freshMetadata.MatchedWords.Single(freshMatchedWord => freshMatchedWord.Address == matchedWord.Address); Assert.Equal(newMatchedWord.Name, matchedWord.Name); Assert.Equal(newMatchedWord.AddOffset, matchedWord.AddOffset); Assert.Equal(newMatchedWord.MultOffset, matchedWord.MultOffset); Assert.Equal(newMatchedWord.Note, matchedWord.Note); } // every anchor in the fresh metadata should be represented in the upgrade case var upgradeAnchorNames = upgradedMetadata.NamedAnchors.Select(na => na.Name).ToList(); foreach (var namedAnchor in freshMetadata.NamedAnchors) { Assert.Contains(namedAnchor.Name, upgradeAnchorNames); } // every anchor in the upgraded metadata should have the right address and format to match the fresh versions foreach (var namedAnchor in upgradedMetadata.NamedAnchors) { var newNamedAnchor = freshMetadata.NamedAnchors.Single(anchor => anchor.Name == namedAnchor.Name); Assert.Equal(newNamedAnchor.Address, namedAnchor.Address); Assert.Equal(newNamedAnchor.Format, namedAnchor.Format); } foreach (var offsetPointer in upgradedMetadata.OffsetPointers) { var newOffsetPointer = freshMetadata.OffsetPointers.Single(pointer => pointer.Address == offsetPointer.Address); Assert.Equal(newOffsetPointer.Offset, offsetPointer.Offset); } }
public static IDataModel PokemonModel(byte[] data, StoredMetadata metadata, Singletons singletons) => new PokemonModel(data, metadata, singletons);
public static IDataModel HardcodeTablesModel(Singletons singletons, byte[] rawData, StoredMetadata metadata = null) => new HardcodeTablesModel(singletons, rawData, metadata);
public void OldMetadata_Upgrade_MetadataMatchesNewLoad(string romName, string tomlName) { Skip.IfNot(File.Exists(romName), "Test cannot run without a real rom"); var singletons = BaseViewModelTestClass.Singletons; var tomlPath = "../../../../../src/HexManiac.Tests/toml_versions/"; var fileData = File.ReadAllBytes(romName); var code = fileData.GetGameCode(); tomlPath += code + tomlName; var oldMetadata = new StoredMetadata(File.ReadAllLines(tomlPath)); var upgradedModel = new HardcodeTablesModel(singletons, fileData, oldMetadata); var freshModel = new HardcodeTablesModel(singletons, fileData, new StoredMetadata(new string[0])); var upgradedMetadata = upgradedModel.ExportMetadata(singletons.MetadataInfo); var freshMetadata = freshModel.ExportMetadata(singletons.MetadataInfo); // verify that the content is the same Assert.Equal(upgradedMetadata.FreeSpaceBuffer, freshMetadata.FreeSpaceBuffer); // FreeSpaceSearch is allowed to be different Assert.Equal(upgradedMetadata.Version, freshMetadata.Version); Assert.Equal(upgradedMetadata.NextExportID, freshMetadata.NextExportID); // there may be some old non-deleted lists in upgradedMetadata. That's ok. // but for every list in the fresh metadata, make sure the upgraded metadata has it. foreach (var list in freshMetadata.Lists) { var updateList = upgradedMetadata.Lists.Single(updatedList => updatedList.Name == list.Name); Assert.Equal(list.Count, updateList.Count); Assert.All(updateList.Contents.Count.Range(), i => Assert.Equal(list.Contents[i], updateList.Contents[i])); } foreach (var matchedWord in upgradedMetadata.MatchedWords) { var newMatchedWord = freshMetadata.MatchedWords.Single(freshMatchedWord => freshMatchedWord.Address == matchedWord.Address); Assert.Equal(newMatchedWord.Name, matchedWord.Name); Assert.Equal(newMatchedWord.AddOffset, matchedWord.AddOffset); Assert.Equal(newMatchedWord.MultOffset, matchedWord.MultOffset); Assert.Equal(newMatchedWord.Note, matchedWord.Note); } // every anchor in the fresh metadata should be represented in the upgrade case var upgradeAnchorNames = upgradedMetadata.NamedAnchors.Select(na => na.Name).ToList(); foreach (var namedAnchor in freshMetadata.NamedAnchors) { Assert.Contains(namedAnchor.Name, upgradeAnchorNames); } // every anchor in the upgraded metadata should have the right address and format to match the fresh versions foreach (var namedAnchor in upgradedMetadata.NamedAnchors) { bool exemptAddress = false, exemptFormat = false; if (tomlName == "_0.4.0.toml") { exemptAddress |= new[] { // legitimate moves: same name, new location "graphics.gamecorner.game.palette", "graphics.bag.inside2.palette", }.Contains(namedAnchor.Name); exemptFormat |= new[] { // legitimate format changes: same name, new format "graphics.gamecorner.game.palette", "scripts.specials.thumb", }.Contains(namedAnchor.Name); } if (tomlName == "_0.3.0.toml" || tomlName == "_0.3.5.toml") { exemptFormat |= new[] { // legitimate format changes: same name, new format "scripts.specials.thumb", }.Contains(namedAnchor.Name); } var newNamedAnchor = freshMetadata.NamedAnchors.Single(anchor => anchor.Name == namedAnchor.Name); if (!exemptAddress) { Assert.True(newNamedAnchor.Address == namedAnchor.Address, $"Did {namedAnchor.Name} move?"); } if (!exemptFormat) { Assert.True(newNamedAnchor.Format == namedAnchor.Format, $"Did {namedAnchor.Name} get a new format? {newNamedAnchor.Format} (new) != {namedAnchor.Format} (old)"); } } foreach (var offsetPointer in upgradedMetadata.OffsetPointers) { var newOffsetPointer = freshMetadata.OffsetPointers.Single(pointer => pointer.Address == offsetPointer.Address); Assert.Equal(newOffsetPointer.Offset, offsetPointer.Offset); } }