public void Send_Given30TosAnd30Bccs_SendTwoBatches()
        {
            var senderMock = new Mock<IEmailSender>();
            var service = new Portal.EmailService.EmailService(senderMock.Object);

            var tos = new List<string>();
            var bccs = new List<string>();
            const string from = "*****@*****.**";
            const string subject = "Test Email";
            const string body = "<div>Hallo test</div>";

            for (var i = 0; i < 30; i++)
                tos.Add(string.Format("MyMail{0}@test.test", i));
            for (var i = 0; i < 30; i++)
                bccs.Add(string.Format("MyBccMail{0}@test.test", i));

            IList<SendEmailRequest> request = new List<SendEmailRequest>();

            senderMock.SetupGet(s => s.MaxRecipientPerBatch).Returns(50);
            senderMock.Setup(s => s.Send(It.IsAny<SendEmailRequest>())).Callback<SendEmailRequest>(request.Add);

            service.Send(from, tos, bccs, subject, body);

            senderMock.Verify(s => s.Send(It.IsAny<SendEmailRequest>()), Times.Exactly(2));

            Assert.That(request.Count, Is.EqualTo(2));
            Assert.That(request.First().Destination.ToAddresses.Count, Is.EqualTo(30));
            Assert.That(request.First().Destination.BccAddresses.Count, Is.EqualTo(20));
            Assert.That(request.Skip(1).First().Destination.ToAddresses.Count, Is.EqualTo(0));
            Assert.That(request.Skip(1).First().Destination.BccAddresses.Count, Is.EqualTo(10));
        }
Exemple #2
0
        public void ShouldHaveImportantViaAddress()
        {
            int symbolNumber = 0;

            var symbols = new List<Symbol>();
            //reverse order according to type importance. This is not optimal, but the actual
            //importance is private to Symbol type.
            foreach(var type in new []{ SymbolType.Function,
                SymbolType.NotSpecified,
                SymbolType.ProcessorSpecific,
                SymbolType.Section,
                SymbolType.Object,
                SymbolType.File })
            {
                foreach(var binding in new []{ SymbolBinding.Global,
                    SymbolBinding.Local,
                    SymbolBinding.ProcessorSpecific,
                    SymbolBinding.Weak })
                {
                    symbols.Add(new Symbol(0, 10, symbolNumber.ToString(), type, binding));
                    symbolNumber++;
                }
            }
            //check every symbol. The symbol in question and all LESS important are added, both in order and in reverse order.
            for(var i = 0; i < symbols.Count; ++i)
            {
                var lookup = new SymbolLookup();
                lookup.InsertSymbols(symbols.Skip(i));
                Assert.AreEqual(symbols[i], lookup.GetSymbolByAddress(5));
                lookup = new SymbolLookup();
                lookup.InsertSymbols(symbols.Skip(i).Reverse());
                Assert.AreEqual(symbols[i], lookup.GetSymbolByAddress(5));
            }
        }
 public void Tokens3CorrectDoNothing_Test()
 {
     string String = "{0} {1} {2}";
     List<int> List = new List<int> { 0, 1, 2 };
     FixStringAndList(ref String, ref List);
     Assert.AreEqual("{0} {1} {2}", String);
     Assert.AreEqual(0, List.First());
     Assert.AreEqual(1, List.Skip(1).First());
     Assert.AreEqual(2, List.Skip(2).First());
 }
 public void Tokens3singleDup_Test()
 {
     string String = "{2} {1} {0}";
     List<int> List = new List<int> { 2, 1, 0 };
     FixStringAndList(ref String, ref List);
     Assert.AreEqual("{0} {1} {2}", String);
     Assert.AreEqual(0, List.First());
     Assert.AreEqual(1, List.Skip(1).First());
     Assert.AreEqual(2, List.Skip(2).First());
 }
Exemple #5
0
        public void RaisesSendingEventForEachRequest()
        {
            _server.OnGet("/foo").RespondWith("awww yeah");

            var client = new RestClient(BaseAddress);
            var sendingEvents = new List<RequestDetails>();
            client.Sending += (sender, args) => sendingEvents.Add(args.Request);
            client.Get(BaseAddress + "/foo?omg=yeah");
            Assert.That(sendingEvents.Single().RequestUri.PathAndQuery, Is.EqualTo("/foo?omg=yeah"));
            Assert.That(sendingEvents.Single().Method, Is.EqualTo("GET"));
            client.Get(BaseAddress + "/foo?omg=nah");
            Assert.That(sendingEvents.Skip(1).Single().RequestUri.PathAndQuery, Is.EqualTo("/foo?omg=nah"));
            Assert.That(sendingEvents.Skip(1).Single().Method, Is.EqualTo("GET"));
        }
        public void Should_Add_Two_Items_To_Existing_List() {
            // Arrange
            IList<int> list = new List<int>(new[] { 1, 2 });

            // Act
            list.AddRange(new[] { 3, 4 });

            // Assert
            list.ShouldNotBeEmpty();
            list.Count.ShouldEqual(4);
            list.First().ShouldEqual(1);
            list.Skip(1).First().ShouldEqual(2);
            list.Skip(2).First().ShouldEqual(3);
            list.Last().ShouldEqual(4);
        }
        public void Add()
        {
            var mruCollection = new MostRecentlyUsedCollection();

            var paths = new List<string>();
            for (int i = 0; i <= mruCollection.MaximumSize; i++)
            {
                paths.Add(
                    string.Format(
                        CultureInfo.InvariantCulture,
                        @"c:\temp\myfile{0}.txt",
                        i));
            }

            for (int i = 0; i < paths.Count; i++)
            {
                mruCollection.Add(paths[i]);
                Assert.That(
                    mruCollection.Select(m => m.FilePath),
                    Is.EquivalentTo(
                        paths
                            .Skip(i >= mruCollection.MaximumSize ? i - mruCollection.MaximumSize + 1 : 0)
                            .Take(i >= mruCollection.MaximumSize ? mruCollection.MaximumSize : i + 1)
                            .Reverse()));
            }
        }
Exemple #8
0
        public void query_paged_post_test()
        {
            var authorId = ObjectId.GenerateNewStringId();
            var subject = ObjectId.GenerateNewStringId();
            var body = ObjectId.GenerateNewStringId();
            var sectionId = ObjectId.GenerateNewStringId();
            var postIds = new List<string>();
            var totalPostCount = 10;
            var replyCountPerPost = 2;
            var pageSize = 2;

            for (var i = 0; i < totalPostCount; i++)
            {
                var postId = _commandService.Execute(new CreatePostCommand(subject, body, sectionId, authorId), CommandReturnType.EventHandled).WaitResult<CommandResult>(10000).AggregateRootId;
                for (var j = 0; j < replyCountPerPost; j++)
                {
                    _commandService.Execute(new CreateReplyCommand(postId, null, body, authorId)).Wait();
                }
                postIds.Add(postId);
            }

            var queryService = ObjectContainer.Resolve<IPostQueryService>();

            for (var pageIndex = 1; pageIndex <= totalPostCount / pageSize; pageIndex++)
            {
                var posts = queryService.Find(new PostQueryOption { SectionId = sectionId, PageInfo = new PageInfo { PageIndex = pageIndex, PageSize = pageSize } }).Posts.ToList();
                Assert.AreEqual(replyCountPerPost, posts.Count());
                var expectedPostIds = postIds.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
                for (var i = 0; i < pageSize; i++)
                {
                    Assert.AreEqual(expectedPostIds[i], posts[i].Id);
                    Assert.AreEqual(replyCountPerPost, posts[i].ReplyCount);
                }
            }
        }
        public void be_able_to_read_all_one_by_one_and_return_empty_slice_at_last()
        {
            const string stream = "read_all_events_forward_should_be_able_to_read_all_one_by_one_and_return_empty_slice_at_last";
            using (var store = EventStoreConnection.Create())
            {
                store.Connect(Node.TcpEndPoint);
                var create = store.CreateStreamAsync(stream, false, new byte[0]);
                Assert.DoesNotThrow(create.Wait);

                var testEvents = Enumerable.Range(0, 5).Select(x => new TestEvent((x + 1).ToString())).ToArray();

                var write = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write.Wait);

                var all = new List<RecordedEvent>();
                var position = Position.Start;
                AllEventsSlice slice;

                while ((slice = store.ReadAllEventsForward(position, 1)).Events.Any())
                {
                    all.Add(slice.Events.Single());
                    position = slice.Position;
                }

                Assert.That(TestEventsComparer.Equal(testEvents, all.Skip(1).ToArray()));
            }
        }
Exemple #10
0
        public void GetFrom_StartId()
        {
            savedIds = savedIds.OrderByDescending(i => i).ToList();

            var firstTwo = repos.GetNewFrom(2).Select(p => p.Id);
            Assert.That(firstTwo, Is.EquivalentTo(savedIds.Take(2)));
            var nextTwo = repos.GetNewFrom(2, firstTwo.Min()).Select(p => p.Id);
            Assert.That(nextTwo, Is.EquivalentTo(savedIds.Skip(2).Take(2)));
        }
 public void Tokens2SimpleInvert_Test()
 {
     string String = "{1} {0}";
     List<int> List = new List<int> { 1, 0 };
     FixStringAndList(ref String, ref List);
     Assert.AreEqual("{0} {1}", String);
     Assert.AreEqual(0, List.First());
     Assert.AreEqual(1, List.Skip(1).First());
 }
        public void Should_Apply_All_Migrations_Up_To_Given_Version()
        {
            var sourceMigrations = new List<IMigration>()
            {
                Mock.Of<IMigration>(m => m.Version == "0.0"),
                Mock.Of<IMigration>(m => m.Version == "0.0.1"),
                Mock.Of<IMigration>(m => m.Version == "0.1"),
            };

            var migrationsService = new MigrationsService();
            foreach (var migration in sourceMigrations)
                migrationsService.Register(migration);

            migrationsService.Migrate("", "0.1");

            int index = 0;
            Mock.Get(sourceMigrations.Skip(index++).First()).Verify(mockmigration => mockmigration.Apply());
            Mock.Get(sourceMigrations.Skip(index++).First()).Verify(mockmigration => mockmigration.Apply());
            Mock.Get(sourceMigrations.Skip(index++).First()).Verify(mockmigration => mockmigration.Apply(), Times.Never);
        }
        public void be_able_to_read_events_slice_at_time()
        {
            var all = new List<RecordedEvent>();
            var position = Position.Start;
            AllEventsSlice slice;

            while (!(slice = _conn.ReadAllEventsForwardAsync(position, 5, false).Result).IsEndOfStream)
            {
                all.AddRange(slice.Events.Select(x => x.Event));
                position = slice.NextPosition;
            }

            Assert.That(EventDataComparer.Equal(_testEvents, all.Skip(all.Count - _testEvents.Length).ToArray()));
        }
        public void be_able_to_read_all_one_by_one_until_end_of_stream()
        {
            var all = new List<RecordedEvent>();
            var position = Position.Start;
            AllEventsSlice slice;

            while (!(slice = _conn.ReadAllEventsForwardAsync(position, 1, false).Result).IsEndOfStream)
            {
                all.Add(slice.Events.Single().Event);
                position = slice.NextPosition;
            }

            Assert.That(EventDataComparer.Equal(_testEvents, all.Skip(all.Count - _testEvents.Length).ToArray()));
        }
        public void SetUp()
        {
            words = Values.AtoZ().SelectMany(c => Enumerable.Range(1, 100).Select(i => c + i)).ToList();

            partitions = Values.AtoZ().Select(c => Partition.Where<string>(s => s.StartsWith(c), named: c));

            partitionedStream = Stream
                .Partitioned<string, int, string>(
                    query: async (q, partition) =>
                    {
                        var wordsInPartition = words
                            .Skip(q.Cursor.Position)
                            .Where(partition.Contains);

                        var b = wordsInPartition
                            .Take(q.BatchSize.Value);

                        return b;
                    },
                    advanceCursor: (query, batch) => { query.Cursor.AdvanceTo(words.IndexOf(batch.Last()) + 1); });

            Formatter.ListExpansionLimit = 100;
            Formatter<Projection<HashSet<int>, int>>.RegisterForAllMembers();
        }
 public void SpeculativeExecution_Pause_Using_All_Stream_Ids()
 {
     var maxProtocolVersion = Cluster.MaxProtocolVersion;
     _testCluster = TestClusterManager.GetNonShareableTestCluster(2, 1, true, false);
     Cluster.MaxProtocolVersion = 2;
     try
     {
         var pooling = PoolingOptions.DefaultOptions(Version.Parse("2.0")).SetCoreConnectionsPerHost(HostDistance.Local, 1);
         var session = GetSession(new ConstantSpeculativeExecutionPolicy(50L, 1), true, null, pooling);
         const int pauseThreshold = 140 * 2;
         var tasks = new List<Task<IPAddress>>();
         var semaphore = new SemaphoreSlim(150 * 2);
         for (var i = 0; i < 512; i++)
         {
             //Pause after the stream ids are in use for the connections
             if (i == pauseThreshold)
             {
                 _testCluster.PauseNode(1);
             }
             semaphore.Wait();
             tasks.Add(session
                 .ExecuteAsync(new SimpleStatement(QueryLocal).SetIdempotence(true))
                 .Continue(t =>
                 {
                     semaphore.Release();
                     return t.Result.Info.QueriedHost.Address;
                 }));
         }
         Task.WaitAll(tasks.Select(t => (Task)t).ToArray());
         _testCluster.ResumeNode(1);
         //There shouldn't be any query using node1 as coordinator passed the threshold.
         Assert.AreEqual(0, tasks.Skip(pauseThreshold).Count(t => t.Result.Equals(_addressNode1)));
         Thread.Sleep(1000);
     }
     finally
     {
         Cluster.MaxProtocolVersion = maxProtocolVersion;
     }
 }
        private List<char> ShiftAlpha(string cipher)
        {
            var alpha = new List<char>(new char[26].Select((a, b) => (char)(b + 97)).ToArray());
            var startIndex = alpha.IndexOf(Convert.ToChar(cipher));

            var alphaNew = new char[alpha.Count];
            alpha.CopyTo(alphaNew);

            alpha.InsertRange(alpha.Count, alphaNew.Take(startIndex));
            return alpha.Skip(startIndex).ToList();
        }
        public void CacheStore_MultipleUris_StoresAll()
        {
            // Arrange

            var servers = new List<Uri>
            {
                Uri1,
                Uri2
            };

            var provider = new DefaultVersionProvider();

            // Act

            provider.CacheStore(servers, Version45);

            // Assert

            var result = provider.CacheLookup(servers.Take(1));
            Assert.AreEqual(Version45, result);

            result = provider.CacheLookup(servers.Skip(1));
            Assert.AreEqual(Version45, result);
        }
        public void Pagination_Returns_True_For_Previous_If_CurrentPage_Greater_Than_1()
        {
            var articles = new List<ArticleView>(GetArticles(34));

            var paginator = new Pagination<ArticleView>(articles.Skip(10).Take(10), 2, 10, articles.Count);

            Assert.That(paginator.HasPrevious, Is.True);
            Assert.That(paginator.HasNext, Is.True);
            Assert.That(paginator.TotalPageCount, Is.EqualTo(4));
        }
        public void SetupTransactionsForBulkBuyers()
        {
            var dataContext = new MagicOnlineBotDb();
            var druegbotCards =
                dataContext.BotCards.Where(
                    p => p.BotId == 4 && !p.Card.Premium && p.Card.MtgoCardId.GetValueOrDefault(0) > 0 && p.Card.CardSet != "DPA").ToList();
            var cardsToTransfer = new List<Card>();

            foreach (var druegbotCard in druegbotCards)
            {
                for (int i = 0; i < druegbotCard.OwnedAmount && i < 12; i++)
                {
                    cardsToTransfer.Add(druegbotCard.Card);
                }
            }

            var count = cardsToTransfer.Count;
            var transferCount = count/75;

            _logger.Trace("Count" + count);
            _logger.Trace("TransferCount" + transferCount);

            for (int i = 0; i < transferCount; i++)
            {
                var transfer = new Transfer
                                   {
                                       Completed = false,
                                       TradeBotId = 4,
                                       TradeeId = 173,
                                       WishList =
                                           string.Join(",",
                                                       cardsToTransfer.Skip(i*75).Take(75).Select(p => p.MtgoCardId))
                                   };

                dataContext.Transfers.InsertOnSubmit(transfer);
            }

            dataContext.SubmitChanges();
        }
        public void not_return_events_from_deleted_streams()
        {
            Assert.Inconclusive();

            const string stream = "read_all_events_forward_should_not_return_events_from_deleted_streams";
            using (var store = EventStoreConnection.Create())
            {
                store.Connect(_node.TcpEndPoint);
                var create1 = store.CreateStreamAsync(stream + 1, Guid.NewGuid(), false, new byte[0]);
                Assert.DoesNotThrow(create1.Wait);

                var create2 = store.CreateStreamAsync(stream + 2, Guid.NewGuid(), false, new byte[0]);
                Assert.DoesNotThrow(create2.Wait);

                var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent((x + 1).ToString())).ToArray();

                var write1 = store.AppendToStreamAsync(stream + 1, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write1.Wait);

                var write2 = store.AppendToStreamAsync(stream + 2, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write2.Wait);

                var delete2 = store.DeleteStreamAsync(stream + 2, testEvents.Length);
                Assert.DoesNotThrow(delete2.Wait);

                var all = new List<RecordedEvent>();
                var position = Position.Start;
                AllEventsSlice slice;

                while ((slice = store.ReadAllEventsForward(position, 2, false)).Events.Any())
                {
                    all.AddRange(slice.Events.Select(x => x.Event));
                    position = slice.NextPosition;
                }

                Assert.That(EventDataComparer.Equal(testEvents, all.Skip(1).ToArray()));
            }
        }
        public void Should_Skip_Migrations_Prior_To_Detected_Version()
        {
            var sourceMigrations = new List<IMigration>()
            {
                Mock.Of<IMigration>(m => m.Version == "0.0"),
                Mock.Of<IMigration>(m => m.Version == "0.0.1"),
            };
            var versionDetector = Mock.Of<IVersionDetector>(v => v.GetVersion() == "0.0");
            var migrationsService = new MigrationsService(versionDetector);
            foreach (var migration in sourceMigrations)
                migrationsService.Register(migration);

            migrationsService.Migrate("0.1");

            int index = 0;
            Mock.Get(sourceMigrations.Skip(index++).First()).Verify(mockmigration => mockmigration.Apply(), Times.Never);
            Mock.Get(sourceMigrations.Skip(index++).First()).Verify(mockmigration => mockmigration.Apply());
        }
 private static List<string> GetNumberSequence(List<string> items)
 {
     return items.Skip(1).ToList();
 }
        public void Split_DefersExecution()
        {
            // ReSharper disable PossibleMultipleEnumeration
            var source = new List<int>();

            var query = source.Split(3);

            source.AddRange(new[] { 1, 2, 3, 4, 5, 6, 7 });

            var result = query.ToList();

            Assert.That(result.Count, Is.EqualTo(3));
            CollectionAssert.AreEqual(result[0], source.Take(3));
            CollectionAssert.AreEqual(result[1], source.Skip(3).Take(3));
            CollectionAssert.AreEqual(result[2], source.Skip(6).Take(3));
            CollectionAssert.AreEqual(result.SelectMany(group => group.ToList()), source);

            source.AddRange(new[] { 8, 9, 10 });

            result = query.ToList();

            Assert.That(result.Count, Is.EqualTo(4));
            CollectionAssert.AreEqual(result[0], source.Take(3));
            CollectionAssert.AreEqual(result[1], source.Skip(3).Take(3));
            CollectionAssert.AreEqual(result[2], source.Skip(6).Take(3));
            CollectionAssert.AreEqual(result[3], source.Skip(9).Take(3));
            CollectionAssert.AreEqual(result.SelectMany(group => group.ToList()), source);
            // ReSharper restore PossibleMultipleEnumeration
        }
        public void MessageQueue_AddRange_two_messages_SendFromQueueAsync_twice_writer_receives_both_messages()
        {
            var messageFramesWritten = new List<MessageFrame>();
            var messageFramesWriter = CreateMessageFrameWriter(messageFramesWritten);

            var testMessageFrame1 = new MessageFrame();
            var testMessageFrame2 = new MessageFrame();

            var messageQueue = new MessageQueueSingle();
            messageQueue.AddRange(new[] { testMessageFrame1, testMessageFrame2 });

            messageQueue.SendFromQueueAsync(messageFramesWriter, CancellationToken.None).Wait();
            messageQueue.SendFromQueueAsync(messageFramesWriter, CancellationToken.None).Wait();

            Assert.AreSame(testMessageFrame1, messageFramesWritten.First());
            Assert.AreSame(testMessageFrame2, messageFramesWritten.Skip(1).Single());
        }
        public void be_able_to_read_events_slice_at_time()
        {
            const string stream = "read_all_events_forward_should_be_able_to_read_events_slice_at_time";
            using (var store = EventStoreConnection.Create())
            {
                store.Connect(_node.TcpEndPoint);
                var create = store.CreateStreamAsync(stream, Guid.NewGuid(), false, new byte[0]);
                Assert.DoesNotThrow(create.Wait);

                var testEvents = Enumerable.Range(0, 20).Select(x => TestEvent.NewTestEvent((x + 1).ToString())).ToArray();

                var write = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write.Wait);

                var all = new List<RecordedEvent>();
                var position = Position.Start;
                AllEventsSlice slice;

                while ((slice = store.ReadAllEventsForward(position, 5, false)).Events.Any())
                {
                    all.AddRange(slice.Events.Select(x => x.Event));
                    position = slice.NextPosition;
                }

                Assert.That(EventDataComparer.Equal(testEvents, all.Skip(1).ToArray()));
            }
        }
Exemple #27
0
        public void SkipQueryReuse()
        {
            List<int> data = new List<int> { 1, 2, 3 };
            IEnumerable<int> enumerable = data.Skip(1);

            enumerable.AssertEqual(2, 3);

            data.Add(4);
            enumerable.AssertEqual(2, 3, 4);
        }
        public void MessageQueue_AddRange_two_messages_SendMultipleFromQueue_writer_receives_both_messages()
        {
            var messageFramesWritten = new List<MessageFrame>();
            var messageFramesWriter = CreateMessagFrameWriter(messageFramesWritten);

            var testMessageFrame = new MessageFrame();

            var testMessageFrame1 = new MessageFrame();
            var testMessageFrame2 = new MessageFrame();

            var messageQueue = new MessageQueueBatch(4096);
            messageQueue.AddRange(new[] { testMessageFrame1, testMessageFrame2 });

            messageQueue.SendMultipleFromQueue(messageFramesWriter);

            Assert.AreSame(testMessageFrame1, messageFramesWritten.First());
            Assert.AreSame(testMessageFrame2, messageFramesWritten.Skip(1).Single());
        }
        public void TestSendMessageIteration()
        {
            var array = new List<int>{1,2,3,4,5,6,7,8,9};
            var max = 8;
            var iterations = array.Count / max + 1;

            for (int i = 0; i < iterations; i++)
            {
                array.Skip(i * max).Take(max).ToList<int>().ForEach(it =>{
                    Console.WriteLine(it);
                });
                Console.WriteLine ("---");
            }
        }
        protected virtual void AssertLayout(string sourceSize, string resizeSettings, Action<RectangleF> assertImage, Action<SizeF> assertCanvas)
        {
            var sourceSizeSettings = new ResizeSettings(sourceSize);
            var result = _imageLayoutBuilder.BuildLayout(new Size(sourceSizeSettings.Width, sourceSizeSettings.Height), new ResizeSettings(resizeSettings));
            if (assertCanvas != null)
                assertCanvas(result.CanvasSize);
            if (assertImage != null)
                assertImage(result.Image);

            var maxWidth = (int)(Math.Max(result.Image.Width, result.CanvasSize.Width));
            var maxHeight = (int)(Math.Max(result.Image.Height, result.CanvasSize.Height));

            var padding = (int)Math.Max(Math.Abs(result.Image.Y), Math.Abs(result.Image.X)) + 20;

            if ((maxWidth + padding) < 400)
            {
                padding = (400 - maxWidth) / 2;
            }

            // create a bitmap for visualizing
            var bitmapSize = new RectangleF(0, 0, maxWidth + padding * 2, maxHeight + (padding * 2));
            using (var bmp = new Bitmap((int)bitmapSize.Width, (int)bitmapSize.Height))
            {
                using (var gfx = Graphics.FromImage(bmp))
                {
                    // set the background
                    gfx.FillRectangle(new SolidBrush(Color.White), 0, 0, bmp.Width, bmp.Height);

                    // output the results
                    gfx.DrawString("Source: " + sourceSize, new Font("Thaoma", 8), Brushes.Black, new RectangleF(0, 0, bmp.Width, bmp.Height), new StringFormat { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Near });
                    gfx.DrawString("Destination: " + resizeSettings, new Font("Thaoma", 8), Brushes.Black, new RectangleF(0, 0, bmp.Width, bmp.Height), new StringFormat { Alignment = StringAlignment.Far, LineAlignment = StringAlignment.Near });
                    gfx.DrawString("Canvas: " + result.CanvasSize.Width + "x" + result.CanvasSize.Height, new Font("Thaoma", 8), Brushes.Green, new RectangleF(0, 0, bmp.Width, bmp.Height), new StringFormat { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Far });
                    gfx.DrawString("Image: " + result.Image.Width + "x" + result.Image.Height, new Font("Thaoma", 8), Brushes.Red, new RectangleF(0, 0, bmp.Width, bmp.Height), new StringFormat { Alignment = StringAlignment.Far, LineAlignment = StringAlignment.Far });

                    //PolygonMath.AlignWith()
                    var canvas = new RectangleF(padding, padding, result.CanvasSize.Width, result.CanvasSize.Height);
                    var image = new RectangleF(padding + result.Image.X, padding + result.Image.Y, result.Image.Width, result.Image.Height);
                    var points = new List<PointF>();
                    points.AddRange(PolygonMath.ToPoly(canvas));
                    points.AddRange(PolygonMath.ToPoly(image));
                    points = PolygonMath.AlignWith(points.ToArray(), PolygonMath.ToPoly(bitmapSize), ContentAlignment.MiddleCenter).ToList();
                    canvas = PolygonMath.GetBoundingBox(points.Take(4).ToArray());
                    image = PolygonMath.GetBoundingBox(points.Skip(4).Take(4).ToArray());
                    gfx.FillRectangle(new SolidBrush(Color.Green), canvas);
                    gfx.DrawRectangle(new Pen(Color.Red, 2), image.X, image.Y, image.Width, image.Height);
                }
                var fileName = sourceSize + "--" + resizeSettings + ".bmp";
                var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, fileName);
                if (File.Exists(filePath))
                    File.Delete(filePath);
                bmp.Save(filePath, ImageFormat.Bmp);

                Trace.WriteLine("Source:        " + sourceSize);
                Trace.WriteLine("Destination:   " + resizeSettings);
                Trace.WriteLine("   Result:     " + filePath);
            }
        }