public void Write_Load_Compare_Equal_NoException()
        {
            var scalesManager  = new ScalesManager();
            var xmlLoaderSaver = new XmlLoaderSaver(catchAndLogExceptions: false);

            scalesManager.Request_Load += xmlLoaderSaver.Handle_LoadRequest;
            scalesManager.Request_Save += xmlLoaderSaver.Handle_SaveRequest;

            //Pack and save
            Scale[] originalScales = new Scale[]
            {
                new Scale("C major", keynoteSound: Sound.C, scaleSound: Sound.C | Sound.D | Sound.E | Sound.F | Sound.G | Sound.A | Sound.B),
                new Scale("G major", keynoteSound: Sound.G, scaleSound: Sound.C | Sound.D | Sound.E | Sound.Fd | Sound.G | Sound.A | Sound.B),
                new Scale("D major", keynoteSound: Sound.D, scaleSound: Sound.Cd | Sound.D | Sound.E | Sound.Fd | Sound.G | Sound.A | Sound.B),
            };

            var task = scalesManager.Handle_SaveAdditionalScalesRequestAwaitable(originalScales);

            //Wait
            task.Wait();

            //Load and unpack
            var loadedScales = scalesManager.Handle_LoadAdditionalScalesRequest();

            //Compare
            for (int i = 0; i < originalScales.Length; i++)
            {
                Scale originalScale = originalScales[i];
                Scale loadedScale   = loadedScales[i];

                Assert.AreEqual(originalScale.Name, loadedScale.Name);
                Assert.AreEqual(originalScale.Sound, loadedScale.Sound);
                Assert.AreEqual(originalScale.KeynoteSound, loadedScale.KeynoteSound);
            }
        }
Ejemplo n.º 2
0
        public void Write_Load_Compare_Equal_NoException()
        {
            var settingsManager = new SettingsManager();
            var xmlLoaderSaver  = new XmlLoaderSaver(catchAndLogExceptions: false);

            settingsManager.Request_Load += xmlLoaderSaver.Handle_LoadRequest;
            settingsManager.Request_Save += xmlLoaderSaver.Handle_SaveRequest;

            //Pack and save
            Note[] originalNotes = new Note[]
            {
                new Note(Sound.A),
                new Note(Sound.B),
                new Note(Sound.C)
            };

            var originalSettings = new SettingsRequestEventArgs(Semitone.Sharp, Semitone.Hidden, Semitone.Flat, originalNotes, 5);

            settingsManager.Handle_SaveSettingsRequest(originalSettings);

            //Load and unpack
            var loadedSettings = settingsManager.Handle_LoadSettingsRequest();

            //Compare
            Assert.AreEqual(originalSettings.PianorollSemitone, loadedSettings.PianorollSemitone);
            Assert.AreEqual(originalSettings.FretboardSemitone, loadedSettings.FretboardSemitone);
            Assert.AreEqual(originalSettings.CircleSemitone, loadedSettings.CircleSemitone);
            Assert.AreEqual(originalSettings.LastVisibleString, loadedSettings.LastVisibleString);

            for (int i = 0; i < originalSettings.FretboardStrings.Length; i++)
            {
                Assert.AreEqual(originalSettings.FretboardStrings[i], loadedSettings.FretboardStrings[i]);
            }
        }
        public void Write_Load_Compare_Equal_NoException()
        {
            //Pack and save
            Scale[] originalScales = new Scale[]
            {
                new Scale("C major", keynoteSound: Sound.C, scaleSound: Sound.C | Sound.D | Sound.E | Sound.F | Sound.G | Sound.A | Sound.B),
                new Scale("G major", keynoteSound: Sound.G, scaleSound: Sound.C | Sound.D | Sound.E | Sound.Fd | Sound.G | Sound.A | Sound.B),
                new Scale("D major", keynoteSound: Sound.D, scaleSound: Sound.Cd | Sound.D | Sound.E | Sound.Fd | Sound.G | Sound.A | Sound.B),
            };

            ScaleXmlRepack[] packedScales = new ScaleXmlRepack[originalScales.Length];

            for (int i = 0; i < originalScales.Length; i++)
            {
                var scale = originalScales[i];
                packedScales[i] = new ScaleXmlRepack()
                {
                    Name = scale.Name, Sound = (int)scale.Sound, Keynote = (int)scale.KeynoteSound
                };
            }

            var container = new ScalesXmlContainer()
            {
                Scales = packedScales
            };

            var xmlLoaderSaver = new XmlLoaderSaver(catchAndLogExceptions: false);

            xmlLoaderSaver.Handle_SaveRequest("TestScales.xml", container);

            //Load and unpack
            var loadedContainer = (ScalesXmlContainer)xmlLoaderSaver.Handle_LoadRequest("TestScales.xml", typeof(ScalesXmlContainer));

            packedScales = loadedContainer.Scales;
            int length = packedScales.Length;

            Scale[] loadedScales = new Scale[length];

            for (int i = 0; i < length; i++)
            {
                var packedScale = packedScales[i];
                loadedScales[i] = new Scale(packedScale.Name, (Sound)packedScale.Keynote, (Sound)packedScale.Sound);
            }

            //Compare
            for (int i = 0; i < originalScales.Length; i++)
            {
                Scale originalScale = originalScales[i];
                Scale loadedScale   = loadedScales[i];

                Assert.AreEqual(originalScale.Name, loadedScale.Name);
                Assert.AreEqual(originalScale.Sound, loadedScale.Sound);
                Assert.AreEqual(originalScale.KeynoteSound, loadedScale.KeynoteSound);
            }
        }
        private void RunTestingParametrized(string cultureToRunIn, string defaultCultureToSet)
        {
            var localizationManager = new LocalizationManager(defaultCultureToSet);
            var xmlLoaderSaver      = new XmlLoaderSaver(catchAndLogExceptions: false);

            localizationManager.Request_Load += xmlLoaderSaver.Handle_LoadRequest;
            //localizationManager.Request_Save += xmlLoaderSaver.Handle_SaveRequest; //Testing that this event is indeed unavailable at localizationManager

            //Pack and save
            var originalDictionary = new Dictionary <string, string>()
            {
                { "Interactive Music Scales", "00" },
                { "Clear UI [Esc]", "01" },
                { "Save current scale [Ctrl+S]", "02" },
                { "Delete selected scale [Delete]", "03" },

                { "Cannot save the new scale while other scale is in display", "04" },
                { "Cannot save empty scale", "05" },
                { "Scale successfully saved", "06" },
                { "To delete the scale one must first select it", "07" },
                { "Cannot delete basic scale", "08" },
                { "Delete this scale? Are you sure?", "09" },
                { "Scale deleted", "10" },
            };

            var packedEntries = new List <LocalizationXmlEntry>();

            foreach (var pair in originalDictionary)
            {
                packedEntries.Add(new LocalizationXmlEntry()
                {
                    Key = pair.Key, Value = pair.Value
                });
            }

            var container = new LocalizationXmlRepack()
            {
                Entries = packedEntries.ToArray()
            };

            xmlLoaderSaver.Handle_SaveRequest($"Localization\\{cultureToRunIn}.xml", container);

            //Load and unpack
            Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo(cultureToRunIn);
            var loadedDictionary = localizationManager.Handle_LoadLocalizationRequest();

            //Compare
            foreach (var pair in originalDictionary)
            {
                Assert.AreEqual(originalDictionary[pair.Key], loadedDictionary[pair.Key]);
            }
        }
        public void Write_Load_Compare_Equal_NoException()
        {
            //Pack and save
            var originalDictionary = new Dictionary <string, string>()
            {
                { "apple", "яблоко" },
                { "orange", "апельсинка" },
                { "pizza", "пицца" }
            };

            var packedEntries = new List <LocalizationXmlEntry>();

            foreach (var pair in originalDictionary)
            {
                packedEntries.Add(new LocalizationXmlEntry()
                {
                    Key = pair.Key, Value = pair.Value
                });
            }

            var container = new LocalizationXmlRepack()
            {
                Entries = packedEntries.ToArray()
            };

            var xmlLoaderSaver = new XmlLoaderSaver(catchAndLogExceptions: false);

            xmlLoaderSaver.Handle_SaveRequest("Localization\\Test\\TestLocalization.xml", container);

            //Load and unpack
            container = (LocalizationXmlRepack)xmlLoaderSaver.Handle_LoadRequest("Localization\\Test\\TestLocalization.xml", typeof(LocalizationXmlRepack));

            var unpackedEntries = container.Entries;

            var loadedDictionary = new Dictionary <string, string>();

            foreach (var entry in unpackedEntries)
            {
                loadedDictionary[entry.Key] = entry.Value;
            }

            //Compare
            foreach (var pair in originalDictionary)
            {
                Assert.AreEqual(originalDictionary[pair.Key], loadedDictionary[pair.Key]);
            }
        }
        public void Write_Load_Compare_Equal_NoException()
        {
            //Pack and save
            Note[] originalNotes = new Note[]
            {
                new Note(Sound.A),
                new Note(Sound.B),
                new Note(Sound.C)
            };

            var originalSettings = new SettingsRequestEventArgs(Semitone.Sharp, Semitone.Hidden, Semitone.Flat, originalNotes, 5);

            var packedNotes = new int[originalNotes.Length];

            for (int i = 0; i < packedNotes.Length; i++)
            {
                packedNotes[i] = (int)originalNotes[i].Sound;
            }

            var container = new SettingsXmlRepack()
            {
                PianorollSemitone = (int)originalSettings.PianorollSemitone,
                FretboardSemitone = (int)originalSettings.FretboardSemitone,
                CircleSemitone    = (int)originalSettings.CircleSemitone,

                FretboardStrings = packedNotes,

                LastVisibleString = originalSettings.LastVisibleString
            };

            var xmlLoaderSaver = new XmlLoaderSaver(catchAndLogExceptions: false);

            xmlLoaderSaver.Handle_SaveRequest("TestSettings.xml", container);

            //Load and unpack
            container = (SettingsXmlRepack)xmlLoaderSaver.Handle_LoadRequest("TestSettings.xml", typeof(SettingsXmlRepack));

            int length        = container.FretboardStrings.Length;
            var unpackedNotes = new Note[length];

            for (int i = 0; i < length; i++)
            {
                unpackedNotes[i] = new Note((Sound)container.FretboardStrings[i]);
            }

            var loadedSettings = new SettingsRequestEventArgs
                                 (
                (Semitone)container.PianorollSemitone,
                (Semitone)container.FretboardSemitone,
                (Semitone)container.CircleSemitone,
                unpackedNotes,
                container.LastVisibleString
                                 );

            //Compare
            Assert.AreEqual(originalSettings.PianorollSemitone, loadedSettings.PianorollSemitone);
            Assert.AreEqual(originalSettings.FretboardSemitone, loadedSettings.FretboardSemitone);
            Assert.AreEqual(originalSettings.CircleSemitone, loadedSettings.CircleSemitone);
            Assert.AreEqual(originalSettings.LastVisibleString, loadedSettings.LastVisibleString);

            for (int i = 0; i < length; i++)
            {
                Assert.AreEqual(originalSettings.FretboardStrings[i], loadedSettings.FretboardStrings[i]);
            }
        }
 public static void InitializeFields(TestContext testContext)
 {
     xmlLoaderSaver = new XmlLoaderSaver(catchAndLogExceptions: true);
 }