Dan Gartner's codetastic blog about programming and other things (such as hotdogs, for instance).

Using Assert::ExpectException with Native Unit Testing in VS11

dgartner_live.com — Mon, 23 Apr 2012 00:36:40 GMT

The native unit testing capabilities in VS11 beta are very cool indeed. Being mainly a managed code developer, I was left wondering how to pass a test if an expected exception is thrown (a al the [ExpectedException] attribute I’ve used with MS-TEST in managed code unit tests. With the native unit testing capabilities in VS11, there is no ExpectedException attribute, but there is a static Assert::ExpectException method that we use to verify that our code under test throws an exception. It accepts a lambda or a functor as a parameter. Being a beta, I hadn’t seen too many examples, so I’ve included a couple below.

   1:          TEST_METHOD(ExpectCallThrowException)

   2:          {

   3:              auto func = [this] { throwException();};

   4:              Assert::ExpectException<int>(func);

   5:          }

6:

   7:          void throwException()

   8:          {

   9:              throw 1;

  10:          }

Here is a more realistic example, where my BankAccount class throws an invalid_argument exception if a zero amount is passed in as the parameter.

   1:  double BankAccount::Debit(double amount)

   2:  {

   3:      if(amount == 0)

   4:      {

   5:          throw std::invalid_argument("amount");

   6:      }

   7:      balance -= amount;

   8:      return balance;

   9:  }

10:

  11:  double BankAccount::Credit(double amount)

  12:  {

  13:      if(amount == 0)

  14:      {

  15:          throw std::invalid_argument("amount");

  16:      }

  17:      balance += amount;

  18:      return balance;

  19:  }

And for my test code, we have examples below of using Assert::ExpectException with a lambda, or by catching the exception ourselves and verifying in the test.

1:

   2:  #include <stdexcept>

   3:  #include <functional>

4:

   5:          TEST_METHOD(InvalidArgumentIsThrownWhenDebittingZero)

   6:          {

   7:              BankAccount* sut = new BankAccount();

   8:              double amount = 0.00;

   9:              function<double (void)> f1 = [sut] { return sut->Debit(0.00); };

  10:              Assert::ExpectException<invalid_argument>(f1);

  11:          }

12:

  13:          TEST_METHOD(ExceptionThrownWhenCreditAmountIsZero)

  14:          {

  15:              BankAccount* sut = new BankAccount();

  16:              double amount = 0.00;

  17:              bool exceptionThrown = false;

  18:              try

  19:              {

  20:                  sut->Credit(amount);

  21:              }catch(invalid_argument& ex)

  22:              {

  23:                  auto desc = ex.what();

  24:                  exceptionThrown = true;

  25:              }

  26:              Assert::IsTrue(exceptionThrown);

  27:          }

I haven’t seen too many examples of using Assert::ExpectException, so hopefully this is helpful. If this all changes for the VS11 RTM, I’ll be sure to update this post.

Thanks,
-Dan

Useful Windows and SQL Azure Whitepapers

dgartner_live.com — Wed, 23 Jun 2010 18:28:59 GMT

Below is a collection of useful whitepapers on Windows and SQL Azure that have been recently released. I plan on updating this page as others are released.

Developing and Deploying with SQL Azure

Brief Description

This document provides guidelines on how to deploy an existing on-premise SQL Server database into SQL Azure. It also discusses best practices related to data migration.

Overview

SQL Azure Database is a cloud based relational database service from Microsoft. SQL Azure provides relational database functionality as a utility service. Cloud-based database solutions such as SQL Azure can provide many benefits, including rapid provisioning, cost-effective scalability, high availability, and reduced management overhead.
This document provides guidelines on how to deploy an existing on-premise SQL Server database into SQL Azure. It also discusses best practices related to data migration.

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=45066b7f-a444-4aa8-ae13-88adf5473acd

Security Guidelines for SQL Azure

Brief Description

This document provides an overview of security guidelines for customers who connect to SQL Azure Database, and who build secure applications on SQL Azure.

Overview

SQL Azure Database is a cloud database service from Microsoft. SQL Azure provides Web-facing database functionality as a utility service. Cloud-based database solutions such as SQL Azure can provide many benefits, including rapid provisioning, cost-effective scalability, high availability, and reduced management overhead. This document provides an overview of security guidelines for customers who connect to SQL Azure Database, and who build secure applications on SQL Azure.

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=4322517e-9d80-4ad3-8a75-bf0a10aa64d9

Scaling out with SQL Azure

Brief Description

This paper provides an overview on some scale-out strategies, challenges with scaling out on-premise, and the benefits of scaling out with SQL Azure.

Overview

SQL Azure Database is a cloud database service from Microsoft. SQL Azure provides Web-facing database functionality as a utility service. Cloud-based database solutions such as SQL Azure can provide many benefits, including rapid provisioning, cost-effective scalability, high availability, and reduced management overhead. This paper provides an overview on some scale-out strategies, challenges with scaling out on-premise, and the benefits of scaling out with SQL Azure.

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=4931d76f-0e21-44a7-8699-852eec6ee029

Windows Azure Architecture Guide – Part 1 – Code Samples

Brief Description

Moving Applications to the Cloud
This guide has four accompanying samples, covering all of the scenarios described in the book: a typical on-premises application, the first migration to Windows Azure and subsequent optimizations.

Overview

These samples illustrate the steps towards migration of a typical application built with .NET to the Windows Azure platform. To check for software prerequisites needed to run the samples, run CheckDependencies.cmd in the sample scenarios folder once all content is extracted to your local file system. This batch file launches a dependency checking tool that reports any components that are missing in your system, and it provides links if needed for obtaining, installing and configuring the missing components. Not all of samples require the same components to run.

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=76883a9f-f4aa-4218-add3-1c9b8cc36fc7

Security Best Practices for Developing Windows Azure Applications

Brief Description

A document describing how to build more secure Windows Azure applications

Overview

In this document Microsoft describes some of the security technologies software developers should use, and the security design and development practices they should use to build more secure Windows Azure applications.

http://www.microsoft.com/downloads/details.aspx?familyid=0FF0C25F-DC54-4F56-AAE7-481E67504DF6&displaylang=en

Trying and Retrying in C#

dgartner_live.com — Tue, 09 Mar 2010 21:56:53 GMT

I sometimes encounter a requirement where we want to execute some code and, if that method throws an exception, we want to retry executing it several times until some limit is reached. In this scenario, the thrown exception was expected at times by the application, and could be ignored. The operation was something that failed frequently enough that it was necessary sometimes to retry until it succeeded (web services calls for example may fail due to intermittent connectivity issues).

Another scenario was that if the code failed, we wanted to wait a period of time before retrying. Below is what I came up with.

   1:             var service = new WebService();

   2:              //the type parameter is for the return type of

   3:              //the method we are retrying (GetDataFromRemoteServer()

   4:              //returns a string in this example)

   5:              var retrier = new Retrier<string>();

   6:              //call the service up to 3 times in the event of failure

   7:              string result = retrier.Try(

   8:                  () => service.GetDataFromRemoteServer(), 3);

9:

  10:              //call the service up to 3 times,

  11:              //wait 500ms if there is a failure

  12:              string result2 = retrier.TryWithDelay(

  13:                  ()=> service.GetDataFromRemoteServer(), 3, 500);

And here is the Retrier class. It takes a lambda expression, tries to execute it, and if an exception is thrown, it swallows it and retries executing the code until maxRetries is reached. This is only useful in scenarios where the exception that gets thrown is expected from time to time, and you just want to ignore it and re-execute your code. One way to improve would be to take as a parameter an ExpectedException type, and if the caught exception does not match that, throw. You should never swallow exceptional exceptions. Also, if you try to execute the method the maximum number or retry times, and it is never successful, you probably want to go ahead and rethrow the exception in that case. One scenario I think this might be useful is calling web services where the network connection is prone to failure, thus you want to retry in the event of a failure.

   1:  public class Retrier<TResult>

   2:  {

   3:      public TResult Try(Func<TResult> func,

   4:          int maxRetries)

   5:      {

   6:          TResult returnValue = default(TResult);

   7:          int numTries = 0;

   8:          bool succeeded = false;

   9:          while (numTries < maxRetries)

  10:          {

  11:              try

  12:              {

  13:                  returnValue = func();

  14:                  succeeded = true;

  15:              }

  16:              catch (Exception)

  17:              {

  18:                  //todo: figure out what to do here

  19:              }

  20:              finally

  21:              {

  22:                  numTries++;

  23:              }

  24:              if (succeeded)

  25:                  return returnValue;

  26:          }

  27:          return default(TResult);

  28:      }

29:

  30:      public TResult TryWithDelay(Func<TResult> func, int maxRetries,

  31:          int delayInMilliseconds)

  32:      {

  33:          TResult returnValue = default(TResult);

  34:          int numTries = 0;

  35:          bool succeeded = false;

  36:          while (numTries < maxRetries)

  37:          {

  38:              try

  39:              {

  40:                  returnValue = func();

  41:                  succeeded = true;

  42:              }

  43:              catch (Exception)

  44:              {

  45:                  //todo: figure out what to do here

  46:              }

  47:              finally

  48:              {

  49:                  numTries++;

  50:              }

  51:              if (succeeded)

  52:                  return returnValue;

  53:              System.Threading.Thread.Sleep(delayInMilliseconds);

  54:          }

  55:          return default(TResult);

  56:      }

  57:  }

WPF Attached Behavior Example – Watermark Text

dgartner_live.com — Wed, 11 Nov 2009 16:51:36 GMT

I’ve been working on a relatively simple WPF application lately, in an effort to effectively follow the MVVM pattern, I’ve been working with custom attached properties. In my app, I have some textboxes that I want to contain some default text that is removed when the user tabs into the control:

Unfocused:

Focused:

I could implement an event handler for the GotFocus and LostFocus events, but that would require some code in the code-behind, and isn’t particularly re-usable (show below):

   1:  private void OnInputTextBoxGotFocus(object sender, RoutedEventArgs e)

   2:          {

   3:              var tb = e.OriginalSource as TextBox;

   4:              if (tb != null)

   5:                  ClearTextBox(tb);

   6:          }

7:

   8:          private void ResetTextBox(TextBox tb)

   9:          {

  10:              if (tb.Name == "tbWhat")

  11:                  if (string.IsNullOrEmpty(tb.Text))

  12:                      tb.Text = "What.";

  13:              if (tb.Name == "tbWhere")

  14:                  if (string.IsNullOrEmpty(tb.Text))

  15:                      tb.Text = "Where.";

  16:          }

17:

  18:          private void ClearTextBox(TextBox tb)

  19:          {

  20:              if (tb.Name == "tbWhat")

  21:                  if (tb.Text == "What.")

  22:                      tb.Text = string.Empty;

  23:              if (tb.Name == "tbWhere")

  24:                  if (tb.Text == "Where.")

  25:                      tb.Text = string.Empty;

  26:          }

27:

  28:          private void OnInputTextBoxLostFocus(object sender, RoutedEventArgs e)

  29:          {

  30:              var tb = e.OriginalSource as TextBox;

  31:              if (tb != null)

  32:                  ResetTextBox(tb);

  33:          }

The above code is pretty terrible, and specific to the two textboxes I have on my window (tbWhat and tbWhere). Ugly stuff, that fortunately can be replaced by a more elegant solution. There have been some good blog posts on WPF Attached Behaviors: http://www.mindscape.co.nz/blog/index.php/2009/02/01/attached-behaviours-in-wpf/ and http://www.codeproject.com/KB/WPF/AttachedBehaviors.aspx are what I read to get up to speed.

In my implementation, I want some default text to be displayed in the textbox, and I want to text to disappear when the user focuses into the textbox. To do this, I’m going to have my behavior attach two dependency properties to the textbox, IsWatermarkEnabled and WatermarkText. When IsWatermarkEnabled is set to true or false, I will attach or detach event handlers to the GotFocus and LostFocus events. Below is the complete code listing:

   1:      public static class TextBoxFocusBehavior

   2:      {

   3:          public static string GetWatermarkText(DependencyObject obj)

   4:          {

   5:              return (string)obj.GetValue(WatermarkText);

   6:          }

7:

   8:          public static void SetWatermarkText(DependencyObject obj, string value)

   9:          {

  10:              obj.SetValue(WatermarkText, value);

  11:          }

12:

  13:          public static bool GetIsWatermarkEnabled(DependencyObject obj)

  14:          {

  15:              return (bool)obj.GetValue(IsWatermarkEnabled);

  16:          }

17:

  18:          public static void SetIsWatermarkEnabled(DependencyObject obj, bool value)

  19:          {

  20:              obj.SetValue(IsWatermarkEnabled, value);

  21:          }

22:

  23:          public static readonly DependencyProperty IsWatermarkEnabled =

  24:              DependencyProperty.RegisterAttached("IsWatermarkEnabled",

  25:              typeof(bool), typeof(TextBoxFocusBehavior),

  26:              new UIPropertyMetadata(false, OnIsWatermarkEnabled));

27:

  28:          public static readonly DependencyProperty WatermarkText =

  29:              DependencyProperty.RegisterAttached("WatermarkText",

  30:              typeof(string), typeof(TextBoxFocusBehavior),

  31:              new UIPropertyMetadata(string.Empty, OnWatermarkTextChanged));

32:

  33:          private static void OnWatermarkTextChanged(object sender, DependencyPropertyChangedEventArgs e)

  34:          {

  35:              TextBox tb = sender as TextBox;

  36:              if (tb != null)

  37:              {

  38:                  tb.Text = (string) e.NewValue;

  39:              }

  40:          }

41:

  42:          private static void OnIsWatermarkEnabled(object sender, DependencyPropertyChangedEventArgs e)

  43:          {

  44:              TextBox tb = sender as TextBox;

  45:              if (tb != null)

  46:              {

  47:                  bool isEnabled = (bool)e.NewValue;

  48:                  if (isEnabled)

  49:                  {

  50:                      tb.GotFocus += OnInputTextBoxGotFocus;

  51:                      tb.LostFocus += OnInputTextBoxLostFocus;

  52:                  }

  53:                  else

  54:                  {

  55:                      tb.GotFocus -= OnInputTextBoxGotFocus;

  56:                      tb.LostFocus -= OnInputTextBoxLostFocus;

  57:                  }

  58:              }

  59:          }

60:

  61:          private static void OnInputTextBoxLostFocus(object sender, RoutedEventArgs e)

  62:          {

  63:              var tb = e.OriginalSource as TextBox;

  64:              if (tb != null)

  65:              {

  66:                  if (string.IsNullOrEmpty(tb.Text))

  67:                      tb.Text = GetWatermarkText(tb);

  68:              }

  69:          }

70:

  71:          private static void OnInputTextBoxGotFocus(object sender, RoutedEventArgs e)

  72:          {

  73:              var tb = e.OriginalSource as TextBox;

  74:              if (tb != null)

  75:              {

  76:                  if (tb.Text == GetWatermarkText(tb))

  77:                      tb.Text = string.Empty;

  78:              }

  79:          }

  80:      }

To attach this behavior to my textbox in XAML, I first add an xmlns reference to my behaviors namespace: xmlns:local="clr-namespace:StopForgetting.Behaviors" and add the behavior to the TextBox XAML:

 <TextBox x:Name="tbWhere" local:TextBoxFocusBehavior.IsWatermarkEnabled="true" local:TextBoxFocusBehavior.WatermarkText="Where." Style="{StaticResource InputBox}" Width="150" Margin="5"></TextBox>

And that’s it. Much more re-usable than placing event handlers in the code-behind.

ASP.Net AJAX – Seadragon AJAX Control – making it work with DeepZoomPix

dgartner_live.com — Thu, 22 Oct 2009 18:01:36 GMT

The latest version of the AJAX Control Toolkit includes a new SeaDragon control that allows you to DeepZoom images with pure JavaScript. This is very cool, however, the instructions for embedding the viewer seem to already be out of date.

The instructions tell you to “copy the URL that appears at the bottom” after you have uploaded your image. Since PhotoZoom has changed to DeepZoomPix, these instructions no longer apply (there is no URL at the bottom of the image in DeepZoomPix).

Fiddler Workaround

Until they update the documentation, you can use fiddler to discover the appropriate url for your DeepZoom image.

After adding your image to a DeepZoomPix album, launch Fiddler and browse to your album. Fiddler should capture a series of requests that looks something like this:

The url you are interested will point to an xml file and will start with something similar to /DZ/100/0/Image/ (look for that Image directory). Right click and copy the URL.

Then, navigate back to the Live Labs Seadragon Wizard, and paste the url into the appropriate textbox (shown below) and you should be good to go.

Here is the final product:

Hope this helps,

-Dan