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