The solution to this is to use MiniTool Partition Wizard Home Edition to format the SD card with FAT32.  However, when formatting the card with FAT32, you need to set the cluster size to 32KB, otherwise when you try to use the card with the GoPro you’ll get the error message “SD ERR”.

There’s two ways to connect the Hero3 to an iPad:

• Take the SD  card out of the GoPro and insert the SD card into the iPad’s SD Card Camera Reader cable / Camera Kit
• Plug the USB port of the GoPro into the iPad’s USB Camera Reader cable / Camera Kit

If you’re going down the USB cable route, you’ll probably get the error message “Cannot Use Device.  The connected USB device requires too much power.”  You can fix this by placing a powered USB2 hub between the iPad and the GoPro.  Doing this makes the GoPro draw its power from the hub instead of the iPad.

• There is a change to the behaviour of the Model Binder.  In MVC.NET 1, when a string property had no value to be bound to it, the Model Binder would assign an empty string to the property.  In MVC.NET 2 the model binder will assign null instead.  This can cause many issues.  See http://brianreiter.org/2010/09/16/asp-net-mvc-2-0-undocumented-model-string-property-breaking-change/ for more info.  I’d recommend getting used to the new MVC.NET 2 behaviour instead of using ModelBinders.Binders.DefaultBinder to go back to the MVC.NET 1 behaviour.
• By default you can no longer return JSON from an Action that accepts HTTP GETs.  This is with good reason and closes up some serious potential security holes.  If you understand the implications, you can bypass this restriction on a case-by-case basis using the new overload of the Json method: http://msdn.microsoft.com/en-us/library/ee430920.aspx

[assembly: AssemblyVersionAttribute("1.0.0.0")]
[assembly: AssemblyFileVersionAttribute("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0.0")]

For the last few years I’ve often left the Assembly Version set to a fixed value (e.g. 1.0.0.0) and then set the AssemblyFileVersionAttribute to the something based on a CI build number (e.g. 2.0.0.272 for build 272).

For more info on the purpose of these assembly attributes see: http://all-things-pure.blogspot.co.uk/2009/09/assembly-version-file-version-product.html

You can retrieve the value of the Assembly File Version within code.  This can be useful for things like displaying a version number in your UI.  Here’s the code:

var assemblyFileVersion = (AssemblyFileVersionAttribute)Assembly
  .GetExecutingAssembly()
  .GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false)
  .Single();
return assemblyFileVersion.Version;

It was interesting to see how BDD started as an evolution of Test Driven Development (TDD) but is now as much about stories, acceptance criteria and functional acceptance testing as it is about unit testing.

In preparing for the talk, I spent some time looking at the current state of BDD tools for .NET.  There seem to be four main options:

• Cucumber running on Ruby, with the step definitions written in Ruby
• Cucumber running on IronRuby, with the step definitions written in Ruby
• Cuke4Nuke running on Ruby, with the step definitions written in C#
• SpecFlow running on .NET, with the step definitions written in C#

To help with understanding how Cuke4Nuke works, I’ve ported Cucumber’s calculator example over to C# and Cuke4Nuke.  The code is available on GitHub: https://github.com/simondean/cuke4nuke-examples

In the discussion time after the talk, some interesting topics came up:

• Adopting BDD on a brownfield project
• Executing BDD features against a system “in-process” vs via a web browser or HTTP request
• Exposing a REST API to test the behaviour of a web-UI-based system instead of testing via the web UI

The slides from the talk are available here.

public static class Singleton<T>
  where T : class, new()
{
  public static T Instance
  {
    get
    {
      return Nested.Instance;
    }
  }

  class Nested
  {
    internal static readonly T Instance = new T();

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static Nested()
    {
    }    
  }
}
The class is based on Jon’s fifth version of a singleton implementation.  With Jon’s approach, you have to copy the singleton code into your class that you want to make a singleton.  With my variation, you can copy the Singleton<T> class into any C# project (or compile it into a reusable assembly) and then reuse it with any .NET class that has a default constructor.  You access the singleton instance of a class like this: Singleton.Instance 
Here’s an example of using the Singleton class:
public class HelloWorldService
{
  public HelloWorldService
  {
    System.Console.WriteLine("New object!");
  }
  
  public void SayHello()
  {
    System.Console.WriteLine("Hello World!");
  }

  public void SayGoodbye()
  {
    System.Console.WriteLine("Goodbye World!");
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Singleton<HelloWorldService>.Instance.SayHello();
    Singleton<HelloWorldService>.Instance.SayGoodbye();
  }
}

When you run the example you get this console output:
New object!
Hello World!
Goodbye World!

]]>
			http://www.simondean.org/2010/12/generic-singleton/feed/
		0
		
		
		
		http://www.simondean.org/2009/12/using-webdriver-with-csharp/
		http://www.simondean.org/2009/12/using-webdriver-with-csharp/#comments
		Sun, 06 Dec 2009 18:58:30 +0000
		Simon Dean
				
		
		
		
		

		http://www.simondean.org/?p=28
		
				You can read my previous post if you’re interested in the background to this post. What follows is a step-by-step guide for using WebDriver from C# test code.

Preparation
What you’ll need:

IKVM.NET.  I used version 0.40.0.1 and the download was called ikvmbin-0.40.0.1.zip
WebDriver “all”.  The download will be called something like webdriver-all-7376.zip

Once you’ve downloaded them, extract the two ZIPs on to your computer.
Recompile WebDriver from Java to .NET
Open up a command window and change directory to the directory where you extracted the WebDriver files.
Run the following from the command prompt (all on one line):
path\to\ikvm\bin\ikvmc.exe -out:webdriver-all.dll -target:library *.jar
The above line uses ikvmc.exe to recompile the WebDriver Java code into managed .NET classes.  The managed .NET classes are placed in the webdriver-all.dll assembly.
When I run ikvmc.exe it spits out about 1200 lines of warning messages!  However everything seems to work fine regardless.  I wouldn’t worry too much about the warning messages, but if anyone has the time, it’s worth digging into them (first thing to try would be to replace *.jar in the ikvmc.exe command line with a space separated list of all the WebDriver .jar files – with the files ordered so that every .jar file appears in the list after all the .jar files its dependent on).  Some of the warning messages like duplicate class name… and skipping class…class is already available in referenced assembly… are harmless.
Using WebDriver from a Visual Studio Project
Open Visual Studio 2008 and create a new C# Console Application project  called WebDriverAndCSharp.
Right click the project in Solution Explorer and add a references to the following DLLs:

The webdriver-all.dll that you created above
All the DLLs in the bin directory that you extracted from the IKVM.NET download – except don’t add a reference to the ikvm-native.dll file




Adding ikvm-native.dll to the Project
IKVM.NET also depends on a native (non-managed) DLL called ikvm-native.dll.  You can’t add ikvm-native.dll as a project reference due to a limitation of Visual Studio.  Instead you need to add a link to the ikvm-native.dll file by doing the following:

Right click the project in Solution Explorer and click Add\Existing Item…
In the Add Existing Item dialog box that appears:

Select Executable Files (*.exe; *.dll; *.ocx) in the drop down list of file types
Browse to the directory where you extracted the IKVM.NET download
Select the ikvm-native.dll file in the bin subdirectory
Click the down arrow next to the Add button (don’t actually click the Add button) and select Add As Link



Next, right click ikvm-native.dll in the Solution Explorer and click properties. Change the Build Action to None and set Copy to Output Directory to Copy Always.
Amended properties for ikvm-native.dll
Adding the Example Code
Open the Program.cs file and replace its contents with the following:
namespace WebDriverAndCSharp
{
  using org.openqa.selenium;
  using org.openqa.selenium.firefox;
  using org.openqa.selenium.htmlunit;
  using org.openqa.selenium.ie;

  public class Program
  {
    public static void Main(string[] args)
    {
      SearchTheWeb(new HtmlUnitDriver());
      SearchTheWeb(new FirefoxDriver());
      SearchTheWeb(new InternetExplorerDriver());
      SearchTheWeb(new ChromeDriver());
      `
      System.Console.Out.WriteLine("Press ENTER to exit");
      System.Console.In.ReadLine();
    }

    public static void SearchTheWeb(WebDriver driver)
    {
      // And now use this to visit Google
      driver.get("http://www.google.com");

      // Find the text input element by its name
      WebElement element = driver.findElement(By.name("q"));

      // Enter something to search for
      element.sendKeys("Cheese!");

      // Now submit the form. WebDriver will find
      // the form for us from the element
      element.submit();

      // Check the title of the page
      System.Console.Out.WriteLine(
        "Page title is: " + driver.getTitle());

      driver.quit();
    }
  }
}

The C# code above is a translation of the Java-based WebDriver example code given on the WebDriver’s Getting Started page.
Running the Example
Press F5 to launch the console app you’ve created.  If all goes well, after a few seconds you should see a Firefox window open and perform a search on Google for “Cheese!”.  You should then see Internet Explorer do the same.  When the app has finished – assuming nothing went wrong – the console app should look like this:
Page title is: Cheese! - Google Search
Page title is: Cheese! - Google Search
Page title is: Cheese! - Google Search
Press ENTER to exit

Now press the ENTER key to exit the console app.  The console app should then close.  If it doesn’t, then part of WebDriver may not have closed down cleanly – a problem which I’ve only encountered with Google Chrome (you’ll notice that Chrome is missing from the code example above).
If Something Went Wrong
When you run the example, if you get an exception message saying “The type initializer for ‘com.sun.jna.Native’ threw an exception”, check the build output folder for your project (normally in the directory “bin\Debug” under the directory with your *.csproj file in it) and confirm you can see a file called ikvm-native.dll.  If the DLL isn’t there, take a look back in this posting at the section called Adding ikvm-native.dll to the Project and check you’ve followed all the steps there.  If that doesn’t work for you, another way to get the DLL into your build output directory is to do the following:

Right click the project in Solution Explorer and click Properties.
On the left, click the Build Events tab.
Paste the following into the Post-build event command line textbox.  Make sure you replace path\to with the full path to where  you extracted ikvm-native.dll to (when you extracted the IKVM.NET ZIP file).

copy /y path\to\ikvm-native.dll $(TargetDir)

Following these steps will ensure that the ikvm-native.dll DLL is copied to your build output folder everytime you build the project.
Browser Support
So far I’ve only tested a small fraction of WebDriver’s functionality from C#.  I’ll need to use it for a week or two to really get a feel for how stable WebDriver is when running under IKVM.NET.  However initial impressions suggest that WebDriver with C# works fine with the following browsers:

HtmlUnit
Firefox
Internet Explorer

Google Chrome
I encountered an issue getting Google Chrome working: WebDriver leaves the Google Chrome browser open when the ChromeDriver is closed.  This leads to the console app not terminating properly. It’s a shame because other than that, Chrome seems to work well with WebDriver + .NET.
If you want to try Chrome for yourself, make sure you switch your Chrome browser over to either the beta or dev streams and that your Chrome version is 4.0.206.*+.  I found Google’s Channel Changer app very helpful.
See the WebDriver page on the ChromeDriver for more information on using Chrome with WebDriver.
Update: Daniel Wagner-Hall on the WebDriver discussion group has kindly helped me out with getting ChromeDriver working.  Turns out I should have used driver.quit() instead of driver.close().  I’ve updated the example above to use driver.quit() (see the WebDrive discussion group for more).  With the change, Chrome nolonger stops the console app from finishing.  However I am still seeing Chrome outputting the wrong page title on the console app – unlike the other drivers.
]]>
			http://www.simondean.org/2009/12/using-webdriver-with-csharp/feed/
		7
		
		
		
		http://www.simondean.org/2009/12/moving-away-from-selenium/
		http://www.simondean.org/2009/12/moving-away-from-selenium/#comments
		Sun, 06 Dec 2009 01:40:36 +0000
		Simon Dean
				
		
		
		
		

		http://www.simondean.org/?p=7
		
				Recently I’ve spent a lot of time developing MVC.NET based web apps. The automated functional tests for these web apps have all been written using Selenium, with the tests written in C#  and organized as NUnit test fixtures.

Whilst I found Selenium to be a good tool, I ran into some serious problems with it:

Some of my Selenium based functional tests would fail approximately 10% of the time when they were run against Firefox.   Switching the exact same tests to using Internet Explorer (still with Selenium) resulted in the tests returning to 100% stability.  This meant abandoning automated functional testing with Firefox in favour of using IE.
Slow performance in Internet Explorer (mitigated to some extent by switching the XPath engine Selenium uses with it).  IE just isn’t a fast browser when used with Selenium.
Many of Seleniums operations are non-blocking (i.e. asynchronous).  This means Selenium doesn’t wait for those operations to complete before allowing a test to continue.  For example opening a new webpage in Selenium is a non-blocking operation; Selenium will happily load a page and then (via the next line in the functional test) attempt to click a button on the page when the button hasn’t even loaded yet.

Looking round for an alternative to Selenium, there was one obvious replacement: WebDriver.  In many ways WebDriver is quite similar to Selenium.  However the two differ quite markedly in one regard: Selenium performs its automation using its own JavaScript running within the browser it’s automating whereas WebDriver controls the browser from the outside, using an COM automation API for Internet Explorer and custom browser extensions for Firefox and Google Chrome. The WebDriver approach has proven much more flexible and faster performing than the Selenium approach.  Simon Stewart has written an interesting post on the Google Blog that delves further into this topic.  Another important point in WebDriver’s favour is that Selenium and WebDriver have started to merge into a single project / code base.
Having gotten very interested in WebDriver, I was really surprised to find it doesn’t (yet) support .NET.  At the moment WebDriver can be used from tests written in Java (and Ruby/Python) but not .NET.
Given that I was very keen to use WebDriver with C#, I started to think about any “out of the box” ways I could get this working.  I was thinking some sort of interop bridging or remoting between Java and .NET.
First I looked at the new jni4net project.  jni4net allows you to fireup an instance of the Java Virtual Machine (JVM) from within your .NET application; you can then interact with the java classes running in the JVM using pre-generated .NET proxy classes.  jni4net looked promising but ultimately wasn’t a workable solution; the current version of jni4net isn’t able to generate proxy classes for Java nested static classes – a Java language feature that the WebDriver API relies on.
Then I came across IKVM.NET – a project I’ve read about before but never used.  I’m happy to say I was able to get WebDriver to work with C# using IKVM.NET!! The solution even works with JetBrains ReSharper test runner for Visual Studio. Read my step-by-step guide to getting WebDriver working with C# for more info.
]]>
			http://www.simondean.org/2009/12/moving-away-from-selenium/feed/
		6