public void Test(
[ValueSource(nameof(Cases))] TestCase testCase,
[ValueSource(nameof(BufferSizes))] BufferSize bufferSize,
[ValueSource(nameof(EnginesCount))] int enginesCount,
[ValueSource(nameof(MaxThreadsCount))] int maxThreadsCount)
{
const string inputPath = "ZZZZZzzzzZzZZzzzZZZzzz",
groupsPath = "WWwwwWWwwwWWWwwwwwwwww";
var groupsFileLength = testCase.Lines
.Sum(o => o.Length + Consts.EndLineBytesCount);
byte[] groupsFileContent = new byte[groupsFileLength];
var inputSource = testCase.Lines
.SelectMany(line => new[] { line.Select(c => (byte)c), Consts.EndLineBytes })
.Aggregate(Enumerable.Concat)
.ToArray();
var ioServiceMock = new Mock <IIoService>();
var configMock = new Mock <IConfig>();
ioServiceMock
.Setup(o => o.SizeOfFile(inputPath))
.Returns(groupsFileLength);
ioServiceMock
.Setup(o => o.OpenRead(inputPath, It.IsAny <long>()))
.Returns((string _, long position) =>
{
var inputStream = new MemoryStream(inputSource);
var inputReaderMock = new Mock <IFileReader>();
inputReaderMock
.SetupGet(o => o.Length)
.Returns(() => inputStream.Length);
inputReaderMock
.SetupGet(o => o.Position)
.Returns(() => inputStream.Position);
inputReaderMock
.SetupSet(o => o.Position = It.IsAny <long>())
.Callback((long value) => inputStream.Position = value);
inputReaderMock
.Setup(o => o.ReadByte())
.Returns(() => inputStream.ReadByte());
inputReaderMock
.Setup(o => o.Read(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns((byte[] buff, int offset, int count) =>
inputStream.Read(buff, offset, count));
inputReaderMock
.Setup(o => o.Dispose())
.Callback(() => inputStream.Dispose());
inputReaderMock.Object.Position = position;
return(inputReaderMock.Object);
});
ioServiceMock
.Setup(o => o.OpenWrite(groupsPath, It.IsAny <long>(), false))
.Returns((string _, long position, bool __) =>
{
var groupsStream = new MemoryStream(groupsFileContent);
var writerMock = new Mock <IFileWriter>();
writerMock
.SetupGet(o => o.Position)
.Returns(() => groupsStream.Position);
writerMock
.SetupSet(o => o.Position = It.IsAny <long>())
.Callback((long value) => groupsStream.Position = value);
writerMock
.SetupGet(o => o.Length)
.Returns(() => groupsStream.Length);
writerMock
.Setup(o => o.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Callback((byte[] buff, int offset, int count) =>
groupsStream.Write(buff, offset, count));
writerMock
.Setup(o => o.Dispose())
.Callback(() => groupsStream.Close());
return(writerMock.Object);
});
var maxLineLength = testCase.Lines
.Max(line => line.Length + Consts.EndLineBytesCount);
int buffSize = new Dictionary <BufferSize, int>
{
{ BufferSize.Min, maxLineLength + 1 },
{ BufferSize.Small, maxLineLength + 2 },
{ BufferSize.Medium, groupsFileLength + 1 },
{ BufferSize.Large, groupsFileLength * 2 }
}[bufferSize];
configMock
.SetupGet(o => o.PhysicalBufferLength)
.Returns(buffSize + sizeof(ulong));
configMock
.SetupGet(o => o.UsingBufferLength)
.Returns(buffSize);
configMock
.SetupGet(o => o.MaxRunningTasksCount)
.Returns(maxThreadsCount);
configMock
.SetupGet(o => o.GrouperEnginesCount)
.Returns(enginesCount);
configMock
.SetupGet(o => o.InputFilePath)
.Returns(inputPath);
configMock
.SetupGet(o => o.GroupsFilePath)
.Returns(groupsPath);
IGroupsInfoMarger groupsSummaryInfoMarger =
new GroupsInfoMarger();
ITasksQueue tasksQueue =
new TasksQueue(configMock.Object);
IBuffersPool buffersPool =
new BuffersPool(configMock.Object);
IInputReaderFactory inputReaderMaker =
new InputReaderFactory(
ioServiceMock.Object,
tasksQueue,
buffersPool,
configMock.Object);
IGroupsLinesOutputFactory linesWriterFactory =
new GroupsLinesOutputFactory(
ioServiceMock.Object,
tasksQueue,
buffersPool,
configMock.Object);
IGrouperIOs grouperIOs =
new GrouperIOs(
inputReaderMaker,
linesWriterFactory,
ioServiceMock.Object,
configMock.Object);
var grouper = new Grouper(
groupsSummaryInfoMarger,
grouperIOs,
tasksQueue,
configMock.Object);
var trivialGrouper = new TrivialGrouper();
var expectedGroups = trivialGrouper
.SplitToGroups(testCase.Lines);
var groupsInfo = grouper.SeparateInputToGroups();
var resultGroups = ExtractGroups(groupsInfo, groupsFileContent);
Assert.IsTrue(resultGroups.Select(Group.IsValid).All(o => o));
CollectionAssert.AreEqual(
expectedGroups,
resultGroups);
}
static RedisClient()
{
_buffersPool = new BuffersPool(IoBufferSize, OutputBuffersCount);
_inputBuffersPool = new BuffersPool(IoBufferSize, InputBuffersCount);
_redisPipelinePool = new ObjectsPool <IRedisChannel>();
}
public static void Sort(string input, string output)
{
IConfig config =
new Config(
input,
output);
IGroupsInfoMarger groupsInfoMarger =
new GroupsInfoMarger();
IBuffersPool buffersPool =
new BuffersPool(
config);
IIoService ioService =
new IoService(
buffersPool);
ITasksQueue tasksQueue =
new TasksQueue(
config);
IInputReaderFactory inputReaderFactory =
new InputReaderFactory(
ioService,
tasksQueue,
buffersPool,
config);
IGroupsLinesOutputFactory groupsLinessOutputFactory =
new GroupsLinesOutputFactory(
ioService,
tasksQueue,
buffersPool,
config);
IGrouperIOs grouperIOs =
new GrouperIOs(
inputReaderFactory,
groupsLinessOutputFactory,
ioService,
config);
IGrouper grouper =
new Grouper(
groupsInfoMarger,
grouperIOs,
tasksQueue,
config);
IGroupsLoaderFactory groupsLoaderFactory =
new GroupsLoaderFactory(
buffersPool,
ioService,
config);
ISortingSegmentsSupplier sortingSegmentsSupplier =
new SortingSegmentsSupplier(
config);
ILinesIndexesExtractor linesIndexesExtractor =
new LinesIndexesExtractor(
config);
IGroupSorter groupSorter =
new GroupSorter(
sortingSegmentsSupplier,
linesIndexesExtractor);
ISortedGroupWriterFactory sortedGroupWriterFactory =
new SortedGroupWriterFactory(
ioService,
config);
ISorter sorter =
new Sorter(
ioService,
grouper,
groupsLoaderFactory,
groupSorter,
sortedGroupWriterFactory,
config);
sorter.Sort();
}
