protected override void GivenThat()
{
base.GivenThat();
FileSorter = GenerateMock <ISorter>();
DirectoryInfoProvider = GenerateMock <IDirectoryInfoProvider>();
DirectoryInfo = GenerateMock <IDirectoryInfo>();
FilesInDirectory = new IFileInfo[]
{
GenerateMock <IFileInfo>(),
GenerateMock <IFileInfo>(),
GenerateMock <IFileInfo>()
};
DirectoryInfo.Stub(d => d.GetFiles(null))
.IgnoreArguments()
.Return(FilesInDirectory);
DirectoryInfoProvider.Stub(d => d.GetDirectoryInfo(null))
.IgnoreArguments()
.Return(DirectoryInfo);
FileSorter.Stub(finder => finder.Sort(FilesInDirectory, PodcastFileSortField.FileName, true)).Return(FilesInDirectory);
FileFinder = new Finder(FileSorter, DirectoryInfoProvider);
}
// [TestCase(@"files/example_1GB.txt", @"files/example_expected.txt", 50000)]
public async Task Sort_ProducesCorrectResult(string inputFileName, string expectedOutputFileName, int batchSize)
{
// arrange
var options = new FileSorterOptions
{
BatchSize = batchSize
};
_fixture.Register(() => options);
var outFileName = FileSorter.DefaultOutFileName(inputFileName);
var sorter = _fixture.Create <FileSorter>();
// act
await sorter.Sort(inputFileName, outFileName, CancellationToken.None);
// assert
await using var outputExpectedFile = File.OpenRead(expectedOutputFileName);
using var outputExpectedReader = new StreamReader(outputExpectedFile);
await using var outputActualFile = File.OpenRead(outFileName);
using var outputActualReader = new StreamReader(outputActualFile);
while (!outputExpectedReader.EndOfStream)
{
var expectedLine = await outputExpectedReader.ReadLineAsync();
Assert.IsTrue(!outputActualReader.EndOfStream);
var actualLine = await outputActualReader.ReadLineAsync();
Assert.AreEqual(expectedLine, actualLine);
}
Assert.IsTrue(outputActualReader.EndOfStream);
}
public override void Save()
{
if (_yes)
{
if (DiagnosticsHandler.LogViewerInstance.Visible)
{
return;
}
string logPath = ServiceRegistration.Get <IPathManager>().GetPath("<LOG>");
List <FileInfo> logsfiles = FileSorter.SortByLastWriteTime(logPath, "*.log");
foreach (var file in logsfiles)
{
DiagnosticsHandler.LogViewerInstance.AddLog(file.FullName);
}
SkinContext.Form.Invoke(new ParameterlessMethod(DiagnosticsHandler.LogViewerInstance.Show));
}
else
{
if (!DiagnosticsHandler.LogViewerInstance.Visible)
{
return;
}
DiagnosticsHandler.LogViewerInstance.Dispose();
}
}
/// <exception cref="ArgumentNullException">any argument is null</exception>
/// <exception cref="ArgumentException">defaultDirectory is empty</exception>
public FilesViewPresenter(IFilesView filesView,
IToolBarView toolBarView,
IAddressToolBar addressToolBar,
ICommandsContainer commandsContainer,
IEnvironmentHelper environmentHelper,
Options options,
IMessageHelper messageHelper)
{
Checker.CheckNull(filesView, toolBarView, addressToolBar, commandsContainer, environmentHelper);
this.filesView = filesView;
this.toolBarView = toolBarView;
this.addressToolBar = addressToolBar;
this.commandsContainer = commandsContainer;
this.environmentHelper = environmentHelper;
this.options = options;
this.messageHelper = messageHelper;
sorter = FileSorter.CreateSorter(options.InitialSortColumn, options.InitialSortDirection);
filesView.SortByName += view_SortByName;
filesView.SortByLength += ViewSortByLength;
filesView.SortByType += view_SortByType;
filesView.SortByModifiedDate += ViewSortByModifiedDate;
filesView.OpenDirectory += view_OpenDirectory;
filesView.Cipher += view_Cipher;
filesView.Decipher += view_Decipher;
filesView.ToUpperDirectory += view_ToUpperDirectory;
filesView.SelectedEntityChanged += view_SelectedEntityChanged;
addressToolBar.PathChanged += addressToolBar_PathChanged;
}
public void IsNValidated()
{
FileSorter sorter = new FileSorter();
ArgumentOutOfRangeException ex = Assert.Throws <ArgumentOutOfRangeException>(
delegate { sorter.TopN(@"", 0); });
Assert.That(ex.ParamName, Is.EqualTo("n must be greater than 0"));
}
public void OnLengthClick(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "txt files (*.txt)|*.txt";
if (dialog.ShowDialog(this) == DialogResult.OK)
{
FileSorter.SortByLength(dialog.FileName);
}
}
public void Test_SmallFile_Distinct_Top5()
{
using (var testStreamWriter = new TestStreamWriter(new MemoryStream()))
{
FileSorter sorter = new FileSorter();
sorter.TopN(GetFullTestDataPath("Valid_10Numbers_Distinct.txt"), 5, testStreamWriter);
int[] expected = new int[] { 9, 8, 7, 6, 5 };
int[] actual = testStreamWriter.Data;
Assert.AreEqual(expected, actual);
}
}
public void Test_SmallFile_Negative_Top10()
{
using (var testStreamWriter = new TestStreamWriter(new MemoryStream()))
{
FileSorter sorter = new FileSorter();
sorter.TopN(GetFullTestDataPath("Valid_10Numbers_Negative.txt"), 10, testStreamWriter);
int[] expected = new int[] { 9, 8, 6, 5, 4, 3, 2, 0, -1, -7 };
int[] actual = testStreamWriter.Data;
Assert.AreEqual(expected, actual);
}
}
public MainWindow()
{
Instance = this;
InitializeComponent();
InitTitleBar();
InitFrame();
FileSorter.Init();
_poller = new Poller();
}
public void Test_SmallFile_Duplicates_Top3()
{
using (var testStreamWriter = new TestStreamWriter(new MemoryStream()))
{
FileSorter sorter = new FileSorter();
sorter.TopN(GetFullTestDataPath("Valid_10Numbers_Duplicates.txt"), 3, testStreamWriter);
int[] expected = new int[] { 8, 8, 6 };
int[] actual = testStreamWriter.Data;
Assert.AreEqual(expected, actual);
}
}
public async Task SortFileIntegrationTest()
{
var inputFilePath = await TestsHelper.CreateFile("inputSortingFile.txt", DataStorage.InputData1);
var fileSorter = new FileSorter();
var outputFilePath = await fileSorter.SortFileAsync(inputFilePath);
var actual = await File.ReadAllTextAsync(outputFilePath);
Assert.AreEqual(DataStorage.ExpectedData1, actual);
}
private void ViewSortByModifiedDate(object sender, EventArgs e)
{
if (!(sorter is FileSorterByModifiedDate))
{
sorter = new FileSorterByModifiedDate();
}
else
{
sorter.ChangeDirection();
}
RefreshDirectory();
}
private void view_SortByType(object sender, EventArgs e)
{
if (!(sorter is FileSorterByType))
{
sorter = new FileSorterByType();
}
else
{
sorter.ChangeDirection();
}
RefreshDirectory();
}
public void Test_MediumFile_Duplicates_Top4()
{
using (var testStreamWriter = new TestStreamWriter(new MemoryStream()))
{
FileSorter sorter = new FileSorter();
int resultsReturned = sorter.TopN(
GetFullTestDataPath("Valid_1000000Numbers_Duplicates.txt"), 4, testStreamWriter);
int[] expected = new int[] { 2147483422, 2147483421, 2147483421, 2147483420 };
int[] actual = testStreamWriter.Data;
Assert.AreEqual(expected, actual);
}
}
public void ValidateFile_FileIsValid_ReturnTrue()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"/test/");
fileSystem.AddFile(@"/test/file.xml", new MockFileData("Test"));
var sorter = new FileSorter(fileSystem);
string input = "/test/file.xml";
bool output = sorter.ValidateFile(input);
Assert.True(output);
}
public void ValidateFile_NoFileSelected_InvalidFileException()
{
var sorter = new FileSorter(new MockFileSystem());
try
{
string input = "";
sorter.ValidateFile(input);
}
catch (InvalidFileException e)
{
Assert.Equal("Please select a file", e.Message);
}
}
private IEnumerable <IFileInfo> GetSortedFiles(IDirectoryInfo src, string pattern, PodcastFileSortField sortField, bool ascendingSort)
{
try
{
var fileList = new Collection <IFileInfo>(src.GetFiles(pattern));
return(FileSorter.Sort(fileList, sortField, ascendingSort));
}
catch (DirectoryNotFoundException)
{
// if the folder is not there then there is nothing to do
return(new Collection <IFileInfo>());
}
}
public void Test_SmallFile_Distinct_Top14()
{
// Asking for the top 14 numbers, but file only contains 10 numbers
using (var testStreamWriter = new TestStreamWriter(new MemoryStream()))
{
FileSorter sorter = new FileSorter();
int resultsReturned = sorter.TopN(
GetFullTestDataPath("Valid_10Numbers_Distinct.txt"), 14, testStreamWriter);
int[] expected = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
int[] actual = testStreamWriter.Data;
Assert.AreEqual(expected, actual);
Assert.AreEqual(10, resultsReturned);
}
}
public void FileSorterTest()
{
Assert.IsTrue(Directory.Exists(dirPath));
FileSorter fs = new FileSorter(dirPath);
// Find and sort .txt files by name;
List <string> lsFiles = fs.FindAndSort("txt");
Assert.AreEqual(4, lsFiles.Count);
for (int i = 0; i < lsFiles.Count; i++)
{
string fileName = "File" + (i + 1).ToString("D2") + ".txt";
Assert.AreEqual(Path.GetFileName(lsFiles[i]), fileName);
}
Assert.AreEqual(dirPath, fs.GetDirectory());
}
public static void Main(string[] args)
{
if ("--alph" == args[0])
{
FileSorter.SortByAlphabet(args[1]);
}
else if ("--length" == args[0])
{
FileSorter.SortByLength(args[1]);
}
else
{
Console.WriteLine("Wrong usage.\n./MainConsole.exe [--alph/length] filename");
}
}
private void CreateButton_Click(object sender, RoutedEventArgs e)
{
Destination = Destination.TrimEnd('\\');
Destination = Destination.TrimEnd('/');
if (Directory.Exists(Destination) == false)
{
var results = MessageBox.Show("Directory does not seem to be valid or does not exists, try create a directory?", "Invalid File Path", MessageBoxButton.YesNo);
if (results != MessageBoxResult.Yes)
{
return;
}
try
{
Directory.CreateDirectory(Destination);
}
catch (NotSupportedException)
{
MessageBox.Show("Path is not a valid Windows File Path");
}
catch (Exception exception)
{
MessageBox.Show(
$"Contact developer with the following information: \nFile Path: {Destination}\nException: {exception.Message}");
}
return;
}
if (_rule != null)
{
_rule.ChangeName(NameBox.Text);
_rule.MoveLocation(Destination);
_rule.Type = (RuleType)TypeCombo.SelectedIndex;
_rule.UpdateData(SortBox.Text.Split('\n').ToList());
FileSorter.UpdateRules();
}
else
{
FileSorter.AddRule(
new Rule(
NameBox.Text,
Destination,
SortBox.Text.Split('\n').ToList(),
(RuleType)TypeCombo.SelectedIndex));
}
MainWindow.Instance.NewFloatingFrame(new RulesList());
}
private static int ExecuteSort(SortOptions options)
{
if (!options.Validate())
{
return(1);
}
var sorter = new FileSorter(options);
var timer = Stopwatch.StartNew();
Console.WriteLine($"File '{options.Input}' sort started...");
sorter.Sort();
Console.WriteLine($"File sort executed at {timer.Elapsed}");
return(0);
}
public void ValidateFile_FileDoesNotExist_InvalidFileException()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"/test/");
var sorter = new FileSorter(fileSystem);
try
{
string input = "/test/file.txt";
sorter.ValidateFile(input);
}
catch (InvalidFileException e)
{
Assert.Equal("File not found", e.Message);
}
}
public void ValidateFile_FileIsNotXml_InvalidFileException()
{
var fileSystem = new MockFileSystem();
fileSystem.AddDirectory(@"/test/");
fileSystem.AddFile(@"/test/file.txt", new MockFileData("Test"));
var sorter = new FileSorter(fileSystem);
try
{
string input = "/test/file.txt";
sorter.ValidateFile(input);
}
catch (InvalidFileException e)
{
Assert.Equal("Invalid file", e.Message);
}
}
static void Main(string[] args)
{
var fileSorterParams = new FileSorterParams()
{
InputDataFileName = "TestData_1Gb.txt",
MaxMemoryUsageInBytes = 2 * 1024L * 1024L * 1024L,
OutputSortedFileName = "SortedTestData.txt",
SplittedFileSizeInBytes = 50 * 1024L * 1024L,
SplittedFilesDirectoryName = "TempData",
ProgressInformer = new ConsoleProgressInformer()
};
var fileSorter = new FileSorter(fileSorterParams);
var isSuccess = fileSorter.Sort();
Console.WriteLine($"Is success sorting: {isSuccess}");
Console.ReadLine();
}
public void FileSorter_should_sort_file(string inputPath)
{
var outputPath = $"{inputPath}.sort_test";
var bufferSize = 65 * 1024 * 1024;
var sorter = new FileSorter <TestLine>(
new TestLineParser(),
new LinqSortStrategy(
new TestLineComparer()
),
new TestLineComparer(),
new FileAdapter(),
new FileReader(),
new FileWriter());
sorter.Sort(inputPath, outputPath, bufferSize, bufferSize);
Check_sorting(outputPath);
Check_for_brocken_line(outputPath);
}
public void SortOrdersByDate_UnsortedXmlFile_ReturnOrderedByDate()
{
string xml = @"<?xml version=""1.0""?>
<Root>
<Orders>
<Order><OrderDate>1997-02-12T00:00:00</OrderDate></Order>
<Order><OrderDate>1978-02-12T00:00:00</OrderDate></Order>
<Order><OrderDate>2018-02-12T00:00:00</OrderDate></Order>
</Orders>
</Root>";
XDocument doc = XDocument.Parse(xml);
var sorter = new FileSorter();
XElement[] input = doc.Descendants("Orders").ToArray();
var output = sorter.SortOrdersByDate(input);
Assert.Equal("<Order>\n <OrderDate>1978-02-12T00:00:00</OrderDate>\n</Order>", output[0].ToString());
Assert.Equal("<Order>\n <OrderDate>1997-02-12T00:00:00</OrderDate>\n</Order>", output[1].ToString());
Assert.Equal("<Order>\n <OrderDate>2018-02-12T00:00:00</OrderDate>\n</Order>", output[2].ToString());
}
public static void Main(string[] args)
{
string fileName;
if (args.Length < 1)
{
Console.Write("File name: ");
fileName = Console.ReadLine();
}
else
{
fileName = args[0];
}
if (!File.Exists(fileName))
{
Console.WriteLine($"File '{fileName}' doesn't exist.");
}
var options = Options.Create(new FileSorterOptions
{
BatchSize = 50000
});
var sorter = new FileSorter(options);
var outFileName = FileSorter.DefaultOutFileName(fileName);
var sw = new Stopwatch();
sw.Start();
Task.WaitAll(sorter.Sort(fileName, outFileName, CancellationToken.None));
sw.Stop();
Console.WriteLine($"Sorted. Output: '{outFileName}', elapsed: {sw.Elapsed.TotalSeconds:0.000} s.");
}
protected override void When()
{
SortedFiles = FileSorter.Sort(OriginalFiles, PodcastFileSortField.CreationTime, false);
}
public void IsPathValidated()
{
FileSorter sorter = new FileSorter();
FileNotFoundException ex = Assert.Throws <FileNotFoundException>(
delegate { sorter.TopN(GetFullTestDataPath("1.txt"), 1); });
}
