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;
}
}
