public void DataFilesAndSegments_Full()
        {
            var baseInfo = PackageSequenceBaseInfo.Default;

            // is size is splitted correctly to files and segments?
            // 2 data files + 5.2 segments

            var  sequencer    = new PackagePartsSequencer();
            long testSize     = baseInfo.DataFileLength * 2 + baseInfo.SegmentLength * 520 / 100;
            var  testSequence = new PackageSequenceInfo(baseInfo, testSize);
            var  parts        = sequencer.GetPartsForPackage(@"c:\example", testSequence).ToArray();

            // expected count of parts
            Assert.Equal(parts.Count(), baseInfo.SegmentsPerDataFile * 2 + 6); // two files, 5 full segments and 1 smaller segment

            // expected offsets and indexes
            for (int fileIndex = 0; fileIndex < 3; fileIndex++)
            {
                for (int segmentIndex = 0; segmentIndex < baseInfo.SegmentsPerDataFile; segmentIndex++)
                {
                    int partIndex = fileIndex * baseInfo.SegmentsPerDataFile + segmentIndex;
                    if (partIndex >= parts.Length)
                    {
                        break;
                    }
                    var part = parts[partIndex];

                    // expected offsets
                    Assert.Equal(fileIndex, part.DataFileIndex);
                    Assert.Equal(segmentIndex + fileIndex * baseInfo.SegmentsPerDataFile, part.SegmentIndex);
                    Assert.Equal(segmentIndex * baseInfo.SegmentLength, part.SegmentOffsetInDataFile);

                    if (fileIndex < 2)
                    {
                        // previous full files
                        Assert.Equal(baseInfo.DataFileLength, part.DataFileLength);
                    }
                    else
                    {
                        // last file
                        Assert.Equal(testSize % baseInfo.DataFileLength, part.DataFileLength);
                    }
                }
            }

            // expected sizes - segment sizes
            Assert.Equal(testSize, parts.Sum(a => a.PartLength));
            Assert.All(parts.Take(parts.Length - 1), a => Assert.Equal(baseInfo.SegmentLength, a.PartLength));
            Assert.Equal(testSize % baseInfo.SegmentLength, parts.Last().PartLength); // last segment size
        }
        public void Segments_FullSegment()
        {
            var baseInfo = PackageSequenceBaseInfo.Default;

            // is size is splitted correctly to two segments?
            // 200% of 1 segment
            var  sequencer    = new PackagePartsSequencer();
            long testSize     = baseInfo.SegmentLength * 2; // two full segments
            var  testSequence = new PackageSequenceInfo(baseInfo, testSize);
            var  parts        = sequencer.GetPartsForPackage(@"c:\example", testSequence).ToArray();

            Assert.Equal(2, parts.Count());
            Assert.Equal(baseInfo.SegmentLength, parts[0].PartLength);
            Assert.Equal(baseInfo.SegmentLength, parts[1].PartLength);
            Assert.Equal(0, parts[0].DataFileIndex);
            Assert.Equal(0, parts[1].DataFileIndex);
            Assert.Equal(0, parts[0].SegmentOffsetInDataFile);
            Assert.Equal(baseInfo.SegmentLength, parts[1].SegmentOffsetInDataFile);
        }