public void NameSort_GetSorted_WrittenFileSortedFromList() { List <string> sortedList = new List <string> { "Avie Annakin", "Hailey Annakin", "Erna Dorey Battelle", "Selle Bellison", "Flori Chaunce Franzel", "Orson Milka Iddins", "Odetta Sue Kaspar", "Roy Ketti Kopfen", "Madel Bordie Mapplebeck", "Debra Micheli", "Leonerd Adda Micheli Monaghan", "Leonerd Adda Mitchell Monaghan" }; NameSorter sorter = new NameSorter(); sorter.NameSort("unsorted-names-list-Test.txt"); var path = Directory.GetCurrentDirectory(); List <string> result = File.ReadAllLines(path + "\\" + "sorted-names-list.txt").ToList(); CollectionAssert.AreEqual(result, sortedList); }
public void SortNamesTest() { List <PersonDetail> sortedTestList = new List <PersonDetail>(); sortedTestList.Add(new PersonDetail { GivenName = "Jeff", LastName = "Bezos" }); sortedTestList.Add(new PersonDetail { GivenName = "Bill", LastName = "Gates" }); sortedTestList.Add(new PersonDetail { GivenName = "Elon", LastName = "Musk" }); NameSorter nameSorter = new NameSorter(); nameSorter._nameList.Add(new PersonDetail { GivenName = "Elon", LastName = "Musk" }); nameSorter._nameList.Add(new PersonDetail { GivenName = "Bill", LastName = "Gates" }); nameSorter._nameList.Add(new PersonDetail { GivenName = "Jeff", LastName = "Bezos" }); nameSorter.SortNames(); sortedTestList.Should().BeEquivalentTo(nameSorter.GetNames()); }
public void IncorrectFileNameTest() { NameSorter nameSorter = new NameSorter(); nameSorter.FileName = "xtx.txt"; Assert.Throws <FileNotFoundException>(() => nameSorter.NameSorterProcessor()); }
static void Main(string[] args) { string FileNamePathToWrite; ILogger logger = LogFactory.CreatLogger(); IMessage errorMessage = MessageFactory.CreatMessage(Message.MessageType.Error); IDisplay display; NamesFile file; List <Name> names; try { // //Get file name/path from app.config // FileNamePathToWrite = ConfigurationManager.AppSettings["FileNamePathToWrite"]; // //create screen display object from the factory // display = DisplayFactory.CreatDisplay(); // //get file name and path for reading names from command parameter; file name and path for writing names to is set by program // file = FileInfoValidator.GetFile(args, FileNamePathToWrite); // //only proceed further if file is available // if (file != null) { // // get list of name object by reading // names = ReadNamesHelper.ReadNamesFromStorage(file); // //do sorting on names // names = NameSorter.Sort(names); // //writing sorted names to a storage // WriteNamesHelper.WriteNamesToStorage(file, names); // //display sorted name list on screen // display.DisplayName(names); } } catch (Exception ex) { logger.Log(ex.Message); errorMessage.DisplayMessage(ex.Message); } }
static void Main(string[] args) { NameSorter nameSorter = new NameSorter(); Console.WriteLine("Enter File Name: "); nameSorter.FileName = Console.ReadLine(); nameSorter.NameSorterProcessor(); }
public void TestCheckMoreThanThreeGivenName() { string path = Path.Combine(Environment.CurrentDirectory, "unsorted-names-list.txt"); Sorter s = new NameSorter(new FileOperation(path)); s.SortFullNames(); Assert.AreEqual(true, s.Success); }
public void TestNameSorter() { string input = "unsorted-names-list.txt"; string output = "Test-ouput.txt"; ISorter GlobalXNameSorter = new NameSorter(input, output); GlobalXNameSorter.Sort(); }
public void Sort_NamesShouldSort() { // //names for testing // Name name1 = new Name("John", "Smith"); Name name2 = new Name("Jake Jackson", "Lee"); Name name3 = new Name("Rob", "Smyth"); Name name4 = new Name("Angela", "Nash"); // //unsorted name list // List <Name> unsorted = new List <Name>(); unsorted.Add(name1); unsorted.Add(name2); unsorted.Add(name3); unsorted.Add(name4); // //expected name list // List <Name> expected = new List <Name>(); expected.Add(name2); expected.Add(name4); expected.Add(name1); expected.Add(name3); // //actual sorted name list // List <Name> actual = NameSorter.Sort(unsorted); // //Assert // Assert.Equal(expected[0].FirstName, actual[0].FirstName); Assert.Equal(expected[0].LastName, actual[0].LastName); Assert.Equal(expected[1].FirstName, actual[1].FirstName); Assert.Equal(expected[1].LastName, actual[1].LastName); Assert.Equal(expected[2].FirstName, actual[2].FirstName); Assert.Equal(expected[2].LastName, actual[2].LastName); Assert.Equal(expected[3].FirstName, actual[3].FirstName); Assert.Equal(expected[3].LastName, actual[3].LastName); //Assert.Equal(expected, actual); }
static void Main(string[] args) { IDataProvider dataProvider = new HardcodedDataProvider(); IDataSorter dataSorter = new NameSorter(); var data = dataProvider.GetPeople(); var sortedData = dataSorter.Sort(data); foreach (var item in sortedData) { Console.WriteLine($"{item.name} {item.LastName} {item.Position});
public void StringsWithSpacesQuickSortTest() { // Arrange parameters string[] unsortedAlphabetArray = { "aaaa bbbb", "bbbb aaaa", "aaaa aaaa", "bbbb bbbb" }; string[] sortedAlphabetArray = { "aaaa aaaa", "aaaa bbbb", "bbbb aaaa", "bbbb bbbb" }; // QuickSort NameSorter.QuickSort(unsortedAlphabetArray, 0, unsortedAlphabetArray.Length - 1); // Assert CollectionAssert.AreEqual(unsortedAlphabetArray, sortedAlphabetArray); }
public void AlphanumericCharactersQuickSortTest() { // Arrange parameters string[] unsortedAlphabetArray = { "a1c3", "1337", "33d3", "9cd3" }; string[] sortedAlphabetArray = { "1337", "33d3", "9cd3", "a1c3" }; // QuickSort NameSorter.QuickSort(unsortedAlphabetArray, 0, unsortedAlphabetArray.Length - 1); // Assert CollectionAssert.AreEqual(unsortedAlphabetArray, sortedAlphabetArray); }
public void NumericCharacterQuickSortTest() { // Arrange parameters string[] unsortedAlphabetArray = { "3333", "1111", "2222", "0000" }; string[] sortedAlphabetArray = { "0000", "1111", "2222", "3333" }; // QuickSort NameSorter.QuickSort(unsortedAlphabetArray, 0, unsortedAlphabetArray.Length - 1); // Assert CollectionAssert.AreEqual(unsortedAlphabetArray, sortedAlphabetArray); }
public void DuplicateCaseAlphabetCharacterQuickSortTest() { // Arrange parameters string[] unsortedAlphabetArray = { "aaaa", "bbbb", "bbbb", "aaaa" }; string[] sortedAlphabetArray = { "aaaa", "aaaa", "bbbb", "bbbb" }; // QuickSort NameSorter.QuickSort(unsortedAlphabetArray, 0, unsortedAlphabetArray.Length - 1); // Assert CollectionAssert.AreEqual(unsortedAlphabetArray, sortedAlphabetArray); }
public void IncorrectlySortedQuickSortTest() { // Arrange parameters string[] unsortedAlphabetArray = { "dddd", "cccc", "bbbb", "aaaa" }; string[] incorrectlySortedAlphabetArray = { "aaaa", "bbbb", "dddd", "cccc" }; // QuickSort NameSorter.QuickSort(unsortedAlphabetArray, 0, unsortedAlphabetArray.Length - 1); // Assert CollectionAssert.AreNotEqual(unsortedAlphabetArray, incorrectlySortedAlphabetArray); }
public void TestValidNameSort(IName[] unsortedNames, IName[] expectedResult) { // Quick check to make sure that the test is valid (unsorted and expected result are same length) Assert.Equal(unsortedNames.Length, expectedResult.Length); // Arrange var nameSorter = new NameSorter(); // Act var sortedNames = nameSorter.SortNames(unsortedNames.ToList(), stringComparer); // Assert Assert.Equal(expectedResult, sortedNames); }
public void Test1() { FileReader fileReader = new FileReader(); NameSorter nameSorter = new NameSorter(); //original text file path string unsortedFile = "..\\..\\..\\Files\\unsorted-names-list.txt"; //after sorted text file path string sortedFile = "..\\..\\..\\Files\\sorted-names-list.txt"; List <string> list = fileReader.ReadFileAsStringList(unsortedFile); List <string> unsortedList = nameSorter.ReverseName(list).Select(o => o.Trim()).ToList(); List <string> sortedList = fileReader.ReadFileAsStringList(sortedFile).Select(o => o.Trim()).ToList(); Assert.AreEqual(unsortedList, sortedList); }
public void TestSorterWithSameLastNames() { // Arrange List <Name> input = new List <Name>(); input.Add(new Name("Yuzuru Nishimiya")); input.Add(new Name("Shouko Nishimiya")); List <Name> expected = new List <Name>(); expected.Add(new Name("Shouko Nishimiya")); expected.Add(new Name("Yuzuru Nishimiya")); // Act List <Name> actual = NameSorter.Sort(input); // Assert Assert.Equal(expected, actual); }
public void TestValidNameProcess(string[] unsortedNames, string[] expectedResultArray) { // Quick check to make sure that the test is valid (unsorted and expected result are same length) Assert.Equal(unsortedNames.Length, expectedResultArray.Length); // Arrange var expectedResult = String.Join("\r\n", expectedResultArray); var nameParser = new NameParser(givenNameRegexPattern, surnameRegexPattern); var nameSorter = new NameSorter(); var nameProcessor = new NameProcessor(nameSorter, nameParser); // Act var sortedNames = nameProcessor.ProcessFile(unsortedNames, nameConcat, stringComparer); // Assert Assert.Equal(expectedResult, sortedNames); }
public void PersonNameConverter_PerformSortCorrectly( ) { PersonNameConverter converter = new PersonNameConverter(); NameSorter sorter = new NameSorter(); // Define the test input and expected result string[] rawNames = { "Homer Jay Simpson", "Bart Simpson", "Ned Flanders", "Milhouse Van Houten" }; string[] expectedResult = { "Ned Flanders", "Milhouse Van Houten", "Bart Simpson", "Homer Jay Simpson" }; // create the list of PersonNames to sort List <PersonName> personNames = converter.StringArrayToPersonNameList(rawNames); // perfome the operation that is being tested. The sort operation. personNames = sorter.SortByLastNameThenFirstName(personNames); // if the input and the result are equal both methods worked. Assert.Equal(expectedResult, converter.PersonNameListToStringArray(personNames)); }
public void NameSorter_ShouldWork() { // //names for testing // Name name1 = new Name("John", "Smith"); Name name2 = new Name("Jake Jackson", "Lee"); Name name3 = new Name("Rob", "Smyth"); Name name4 = new Name("Angela", "Nash"); // //unsorted name list // List <Name> unsorted = new List <Name>(); unsorted.Add(name1); unsorted.Add(name2); unsorted.Add(name3); unsorted.Add(name4); // //expected sorted name list // List <Name> expected = new List <Name>(); expected.Add(name2); expected.Add(name4); expected.Add(name1); expected.Add(name3); // //actual sorted name list // List <Name> actual = NameSorter.Sort(unsorted); // //Assert // Assert.Equal(expected, actual); }
public void TestSorterWithUniqueNames() { // Arrange List <Name> input = new List <Name>(); input.Add(new Name("Janet Parsons")); input.Add(new Name("Beau Tristan Bentley")); input.Add(new Name("Hunter Uriah Mathew Clarke")); List <Name> expected = new List <Name>(); expected.Add(new Name("Beau Tristan Bentley")); expected.Add(new Name("Hunter Uriah Mathew Clarke")); expected.Add(new Name("Janet Parsons")); // Act List <Name> actual = NameSorter.Sort(input); // Assert Assert.Equal(expected, actual); }
public void WriteFileTest() { NameSorter nameSorter = new NameSorter(); nameSorter._nameList.Add(new PersonDetail { GivenName = "Elon", LastName = "Musk" }); nameSorter._nameList.Add(new PersonDetail { GivenName = "Jeff", LastName = "Bezos" }); nameSorter._nameList.Add(new PersonDetail { GivenName = "Bill", LastName = "Gates" }); nameSorter.WriteFile("write-test.txt"); var outputMD5 = GetMD5Checksum("write-test.txt"); var baseMD5 = GetMD5Checksum(@"D:\CSharpPractice\GlobalX\unsorted-names-test.txt"); Assert.Equal(baseMD5, outputMD5); }
// Main: Used to demonstrate usage of IFileProcessor & INameSorter functions private static void Main(string[] args) { // 1st argument is taken in as directory param string directory = args[0]; // Initializes FileProcessor & NameSorter IFileProcessor processor = new FileProcessor(directory); INameSorter sorter = new NameSorter(); // Finds filename from given directory, reads file & map to NameModel IEnumerable <NameModel> nameList = processor.ReadFile(FileName.SOURCE); // Performs sorting on name list IEnumerable <NameModel> sortedList = sorter.Sort(nameList); // Writes to console processor.WriteToConsole(sortedList); // Writes to file processor.WriteToFile(sortedList, FileName.DESTINATION); }
public void ReadFile_StoresNames_Test() { List <PersonDetail> testList = new List <PersonDetail>(); testList.Add(new PersonDetail { GivenName = "Jeff", LastName = "Bezos" }); testList.Add(new PersonDetail { GivenName = "Bill", LastName = "Gates" }); testList.Add(new PersonDetail { GivenName = "Elon", LastName = "Musk" }); NameSorter nameSorter = new NameSorter(); nameSorter.FileName = @"D:\CSharpPractice\GlobalX\unsorted-names-test.txt"; nameSorter.ReadFile(); testList.Should().BeEquivalentTo(nameSorter.GetNames()); }
static void Main(string[] args) { var app = new NameSorter(); Console.WriteLine("nameSorter initialised.\n\n"); string input = null; if (args.Length == 0 || !File.Exists(args[0])) { while (input == null) { Console.WriteLine("Please enter correct file path:\n"); input = Console.ReadLine(); if (input != null && (File.Exists(Path.GetFullPath(input)))) { break; } input = null; } } else { input = args[0]; } app.parseFile(input); Console.Write("Reading file...\n"); app.sort(); Console.Write("Sorting...\n"); app.writeToFile(); Console.Write("Writing to file...\n\n"); app.displaySorted(); Console.Write("\n\nSort Complete. Press Any Key to exit..."); Console.ReadKey(true); }
public void SortLastThenFirst_Sorts_Person_List_by_LastName_Then_FirstName() { NameSorter namesorter = new NameSorter(); List <Person> unsorted = new List <Person>(); List <Person> sorted = new List <Person>(); List <Person> expected = new List <Person>(); unsorted.Add(new Person { FirstNames = "Berry Mint", LastName = "Kelvin" }); unsorted.Add(new Person { FirstNames = "Barry Mint", LastName = "Kelvin" }); unsorted.Add(new Person { FirstNames = "Barry Mont", LastName = "Kelvin" }); unsorted.Add(new Person { FirstNames = "Barry Mont", LastName = "Kalvin" }); expected.Add(new Person { FirstNames = "Barry Mont", LastName = "Kalvin" }); expected.Add(new Person { FirstNames = "Barry Mint", LastName = "Kelvin" }); expected.Add(new Person { FirstNames = "Barry Mont", LastName = "Kelvin" }); expected.Add(new Person { FirstNames = "Berry Mint", LastName = "Kelvin" }); sorted = namesorter.SortLastThenFirst(unsorted); CollectionAssert.AreEqual(expected, sorted, "SortLastThenFirst should return a " + "List<Person> sorted in order by LastName and then FirstName"); }
public void SortByName() { NameSorter myComparer = new NameSorter(); this.Sort(myComparer); }
public void MinimalUsageInformation() { Assert.Matches("usage information", NameSorter.ProgramUsageText()); }
public UnitTests() { _nameSorter = new NameSorter(); }
static void SortNames(string path) { Sorter s = new NameSorter(new FileOperation(path)); s.SortFullNames(); }
private async void dataGrid1_Sorting(object sender, DataGridSortingEventArgs e) { ListSortDirection direction = (e.Column.SortDirection != ListSortDirection.Ascending) ? ListSortDirection.Ascending : ListSortDirection.Descending; e.Column.SortDirection = direction; IComparer mySort = null; if (_CTS!=null) { _CTS.Cancel(); _CTS=null; } object CN = e.Column; if (object.ReferenceEquals(CN, NameC)) { mySort = new NameSorter(direction); } else if (object.ReferenceEquals(CN, Rating)) { mySort = new RatingSorter(direction); } else if (object.ReferenceEquals(CN, TrackNumber)) { mySort = new TrackSorter(direction); } else if (object.ReferenceEquals(CN, PlayCount)) { mySort = new PlayCountSorter(direction); } else if (object.ReferenceEquals(CN, LastPLayed)) { mySort = new LastPLayedSorter(direction); } else if (object.ReferenceEquals(CN, DateAdded)) { mySort = new DateAddedSorter(direction); } else if (object.ReferenceEquals(CN, Genre)) { mySort = new GenreSorter(direction); } else if (object.ReferenceEquals(CN, DiscNumber)) { mySort = new DiscNumberSorter(direction); } else if (object.ReferenceEquals(CN, Name)) { mySort = new AlbumNameSorter(direction); } else if (object.ReferenceEquals(CN, Album)) { mySort = new AlbumNameSorter(direction); } else if (object.ReferenceEquals(CN, Artist)) { mySort = new ArtistNameSorter(direction); } else if (object.ReferenceEquals(CN, Year)) { mySort = new YearSorter(direction); } else if (object.ReferenceEquals(CN, SkippedCount)) { mySort = new SkippedCountSorter(direction); } else if (object.ReferenceEquals(CN, Duration)) { mySort = new DurationSorter(direction); } else if (object.ReferenceEquals(CN, Broken)) { mySort = new BrokenSorter(direction); _CTS = new CancellationTokenSource(); e.Handled = true; bool sucess = await TrackStatusLoader.LoadAsync(_CTS.Token); if (!sucess) return; } else if (object.ReferenceEquals(CN, Path)) { mySort = new PathSorter(direction); } if (mySort != null) { LCV.CustomSort = mySort; e.Handled = true; return; } }