My Doc's Got No Nodes

Multi-Channel LPCM on a DVD-ROM

2012-01-28T22:06:00.001Z

(Or how to store 4.0 / 5.1 at 96khz 24-bit on a DVD-R, in a way that plays back properly over HDMI from a Sony BDP-S370)
Yes, another exciting audio howto :-) but if I don’t record it, I won’t be remember (or be willing to rediscover) how.
If starting from one-track-per-file, use foobar2000 to create a single wav file and a cue sheet. The key here is to multi-select the files, and do a convert to wav with the destination type set to “Generate multi-track files”. This will produce the cue sheet.
Next find the duration of the combined wav file, and use ffmpeg from the command prompt to create a still video file:

ffmpeg.exe -loop 1 –i somepicture.png -c:v libx264 -s hd720 -t hh:mm:ss.mmm video.mkv

Then use multiavchd, add video.mkv and click on the entry under “compilation”. Add the audio, then edit the chapters and fill in the values from the cue sheet. On the Author tab I also changed TV system to PAL.
Hit Start, and choose AVCHD (Strict) under the Optical Media section.
From the command prompt multiavchd folder, Use oscdimg to create a UDF disc image of the AVCHD folder

oscdimg -u2 AVCHD myaudiodisc.iso

Burn myaudiodisc.iso to DVD-R. If I let the disc play automatically on loading, the receiver claimed it was being sent 88.2Khz sound. I had to select “AVCHD disc” from the blu-ray player menus to get 96khz.

Compiling Rmpi and doMPI for Windows HPC’s MSMPI

2011-12-21T10:15:00.001Z

For 32-bit only:

To get the Rmpi and doMPI packages working on Windows HPC, using Micrsoft’s MSMPI libraries:

Install the “foreach” package into R.
Install RTools for your version of R from Duncan Murdoch's page.
Install the Windows HPC 2008 SDK from Microsoft Download Center.
Download and extract the package source for the development version (0.6) from The Rmpi download page.
Download and extract the package source for doMPI from the CRAN package page.
Modify the Rmpi\src\Makevars.win to read

PKG_CFLAGS = -I"C:\Program Files\Microsoft HPC Pack 2008 SDK\Include" -DMPI2 -DWin32 "-D__int64=long long"
PKG_LIBS = -L"C:\Program Files\Microsoft HPC Pack 2008 SDK\Lib\i386" -L"C:\Program Files\Microsoft HPC Pack 2008 SDK\Lib\amd64" -lmsmpi

Open an administrative command prompt (so that your R installation can be updated) and do the following:

cd <folder above the extracted packages>

set path=c:\Rtools\bin;c:\Rtools\MinGW\bin;c:\Rtools\MinGW64\bin;%PATH%

"c:\Program Files\R\R-2.14.0\bin\R.exe" --vanilla CMD INSTALL --build Rmpi

"c:\Program Files\R\R-2.14.0\bin\R.exe" --vanilla CMD INSTALL –build doMPI

Copy the zip files created, Rmpi_0.6-0.zip and doMPI_0.1-5.zip, to your cluster head node and pass the file paths to R’s install.packages function together with “foreach”.
library(doMPI) should then state that it has loaded Rmpi.

For 64-bit:

That all worked for i386 (32-bit), but I got an access violation when trying to load the Rmpi package for x64. So instead, I built the Rmpi sources using the Visual C++ 2010 compiler (some fixing required), and dropped the new dlls over the top of the ones installed in the R library folder.

Using parallel foreach on Windows HPC

MSMPI (Microsoft’s implementation of MPI) doesn’t support spawning (at least not in the 2008 R2 version), so you need to use the non-spawning method:

library(doMPI)

cl <- startMPIcluster()

registerDoMPI(cl)

… use of foreach and %dopar% …

closeCluster(cl)

mpi.quit()

Finally, you queue the job using mpiexec on R (or a batch file that calls R).

To run one worker per core:

Set the job resource type to core, and set the minimum and maximum number of cores for the task to the number of cores on your worker nodes.

Use the command mpiexec –n * myRrunner.bat

To run one worker per node:

Set the job resource type to node, and set the minimum and maximum number of nodes for the task to the number of nodes in your cluster.

Use the command mpiexec –cores 1 myRrunner.bat

Playing 24-bit wav files from DVD-R on the Sony BDP-S370

2011-12-14T21:28:00.001Z

In an earlier post, I mentioned that the Sony BDP-S370 can play back 24-bit 44.1Khz LPCM audio if it’s stored as a wav file on a USB memory stick.

Just to add to that, the BDP-S370 can play back PCM (wav files) in 16-bit and 24-bit, 44.1Khz, 48Khz and 96Khz (if not more).

Although it won’t play back wav files via UPnP / DLNA, another option is to burn a DVD-R containing the audio files. This has worked for wav files, and I expect it’ll work for MP3 too.

As usual the S370 is picky about the format it will support, it didn’t like the data disc I burned using the standard Windows 7 DVD-ROM stuff from explorer.

Instead, I used oscdimg.exe with the –u option to generate a UDF image as an ISO file, which I then burned with the Windows 7 right-click burn option. oscdimg is documented here, and is available as a free download as part of the Windows Automated Installation Kit (Windows AIK).

“bootmgr is missing” installing Windows HPC 2008 R2 Compute Nodes

2011-12-12T21:22:00.001Z

Creating a node template from a Windows Server 2008 R2 HPC edition disc, and then PXE booting the cluster nodes seems to leave the cluster node unbootable.

It seems that the default diskpart.txt creates a single partition that the Server 2008 WIM doesn’t initialize correctly.

If instead, you use one of the now unbootable cluster nodes and perform a GUI install into that single partition, you can create a WIM from that node to use with a new compute node template.

Trying to use the GUI install from an unpartitioned disk won’t work, because it overrides your partition choice and creates extra boot / system partitions. If you instead choose to install into the single partition that the diskpart stage created during the failed node install, you’ll get a Windows install that you can use to create your “Golden Image” from, following the instructions on technet: How to Capture a “Master” Compute Node Image Using Node Templates

Extending Wi-fi network range to wireless and wired devices

2011-12-05T22:50:00.001Z

I recently wanted to extend the (woeful) range of the Sky router to get better Wi-fi signal for devices upstairs. I didn’t want to have to run a cable from the router to a new access point, but I thought it would be a bonus to be able to connect wired devices on the new ‘satellite’ network.

It turns out that this is possible with a cheap box from Edimax, the EW-7228APN. It can act as a wireless access point with better coverage (with the same security settings as the main router, but a different SSID) and also connect wired devices and send the traffic wirelessly to the main router.

Setup isn’t obvious though because the documentation isn’t great, so here’s the steps:

From a command prompt, type “ipconfig” and note the ip address and gateway (for a default Sky Broadband setup the ip address will be 192.168.0.something, gateway 192.168.0.1)
Visit the sky router config page in your browser (at 192.168.0.1) and note the wireless security settings.
Connect the access point to the network port of a PC with the supplied cable.
Change the TCP/IPv4 settings of the PC to use the static address 192.168.2.2 subnet mask 255.255.255.0 and leave the gateway blank
Use your web browser to visit 192.168.2.1 to configure the access point, the user name is “admin” and the default password is “1234”.
In the System Utility section, set the IP address to be on your subnet, e.g. 192.168.0.50 (you might want to change the sky router settings to not give out the .50 IP address in its DHCP), and the gateway address to be the address from your ipconfig. Apply but don’t reboot yet.
In the Basic Settings section, choose Repeater, and click Site Survey. Choose your sky router. You may need to choose Repeater again when it returns to the Basic Settings page. Make up a new SSID for the access point. Apply but don’t reboot again.
Go to the Security page and set the security settings to be the same as your Sky router. My router is set to WEP for the benefit of some old-school Nintendo DS Lites, so I set WEP and set the key length and hex codes.
At this point I could apply and reboot. I then needed to change the PC’s TCP/IPv4 settings to be 192.168.0.1 (not the original address) to log back in to the access point at 192.168.0.50 and check everything was still set OK.
Finally, I disconnected the cable and connected wirelessly using the new access point’s SSID and the sky router’s password/key. To do this with Windows 7 I had to create a new connection manually, otherwise I was asked for credentials (no idea what that’s about).
I then set the PC back to dynamically acquire a TCP/IPv4 address, and connected via the wire to check that the PC got a DHCP address on the home network.

Result – the wireless devices have their Wi-fi signal bounced from the access point to the Sky router, but with better coverage, and any wired devices connected to the access point have their traffic sent wirelessly to the router too.

Phew.

Sony BDP-S370 and HDCD

2011-11-14T23:45:00.001Z

(Or playing back 44.1Khz 24 bit lpcm on the S370)

I wasted quite a bit of time trying to work out what kind of container to put HDCD-decoded audio into to get it to play on the BDP-S370.

The short story is this:

The audio should be on a local USB drive (not DLNA). I haven’t looked into DVD-R yet.
The S370 will play 44.1Khz 20-bit from a 24-bit wav file (like HDCD decodes), but the decoder I used had made a wav that the Sony player didn’t like (nor did Windows Media player). Doing a conversion in foobar2000 to a wav with the same bit depth and no resampling made a new 24-bit wav that played fine. I checked the actual bit depth with eac3to and found it to be 17-20 bits as expected.
DVD/DAT style audio at 48Khz will also play fine, as will Hi-Res audio at 96Khz/24-bit. To get 96Khz through my amp (the STR-DH520) I had to set the “Audio Out” setting to “Amp” (not “TV + AMP”), the same was true for playing back SACDs in 5.1.

I might look into higher than 96Khz, or storing the audio on optical discs next. If I’m bored enough :-)

Equipment / Test disc used:

Incidental Mention:

.net 4 Tasks Not Starting

2011-10-26T21:31:00.001+01:00

This is another post about a problem that I could have solved much quicker if I’d found the right blog posts. It’s common enough that .net 4.5 will include a new Task.Run method that saves you from this mistake.

The symptom was that a task that was supposed to run in the background while the UI thread did some other work wasn’t starting – it was scheduled but didn’t run.

The reason was that the supposed background task was started from some code that was (further back in the call stack) inside a task that had been scheduled on the UI thread, using a common pattern of specifying the scheduler.

If you’re already inside a task, creating or starting a new task without specifying a scheduler picks up the scheduler of the parent task, not the default scheduler.

public void ButtonClicked()

{

var onUiThread = TaskScheduler.FromCurrentSynchronizationContext();

var task = new Task(() => DoSomethingInTheBackground());

task.ContinueWith(t => DoSomethingUIRelated(), onUiThread);

task.Start();

}

public void DoSomethingUIRelated()

{

var offUiTask = Task.Factory.StartNew(() => SomethingElseForTheBackground());

///

/// Do some UI-thread stuff

///

offUiTask.Wait();

}

So, on the UI thread, a task is created which calls DoSomethingInBackground. When that is finished, DoSomethingUIRelated is called – on the UI thread by specifying the scheduler onUiThread.

But when the task to call SomethingElseForTheBackground is created, it inherits the UI thread scheduler, and because the UI thread starts a Wait for it, it never gets a chance to run.

The solution is to specify TaskScheduler.Default for offUiTask, or to use the new Task.Run method when .net 4.5 comes along.

Infinite Loop in DLR caching with DynamicObject

2011-03-02T17:12:00.001Z

This is another one of those posts to give the answer to a problem that I couldn’t find with Google.

I was implementing a method call by:

a BindGetMember on a dynamic meta object, returning an expression which returned a new dynamic meta object provider for the method.
a BindInvoke on the dynamic meta object for the method.

Because the dynamic meta object provider for the method didn’t pass itself (i.e. this) into the value parameter for the dynamic meta object representing the method, the binding restrictions created didn’t match the expected type and so they weren’t cached by the CLR.

Instead, it just looped round and round (in System.Dynamic.UpdateDelegates.UpdateAndExecute2) trying to cache the new rule. The fix was to make sure that the DynamicMetaObject has a Value of the original IDynamicMetaObjectProvider instance.

Hope that helps someone else.

.net 4 Client Profile on Mono 2.8

2010-11-01T11:48:00.001Z

If you’re running a .net 4 app built for the .net Client Profile, then you might get the following error when trying to run it on mono:

WARNING: The runtime version supported by this application is unavailable.
Using default runtime: v2.0.50727

To work-around this problem, you can either remove the line

    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0,Profile=Client"/>

From the app.config file (or yourprogram.exe.config), or add the switch

--runtime=v4.0.30319

To the mono command-line.

Troubleshooting Ubuntu Preseed installations

2010-09-08T10:09:00.001+01:00

I hit a problem with doing a preseeded Ubuntu installation, where the partitioning wouldn’t continue without a confirmation.

I found lots of discussions about how to work round the problem with the "write the changes to disks and configure lvm" message, but I could have fixed the problems with a lot less trial and error had I known this earlier:

Edit the “append” line of the pxelinux.cfg/default file to include DEBCONF_DEBUG=5
Press Alt-F4 at the point where the automated install hangs to find out what parameter was missing to cause the user prompt.

Connecting Android Phone to 2 Google Accounts (2nd Update)

2010-07-16T16:33:00.001+01:00

Previous article here

Well now that T-mobile have pushed out the OTA update for the G2 Touch (HTC Hero), I’ve got Android 2.1 and can connect the phone to 2 Google accounts without a problem.

The only minor problem was that the widget for the Gmail inboxes looked identical and didn’t display unread counts.

These two problems were fixed with this great widget by Alexander Blom, there’s a barcode to jump to the marketplace entry on his web page.

SideBySide Event 33 for msvsmon ia64

2010-06-09T09:55:00.001+01:00

If you’re seeing an error in the event log that looks like this:

Activation context generation failed for "C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\Remote Debugger\ia64\msvsmon.exe". Dependent Assembly Microsoft.Windows.Common-Controls,language="*",processorArchitecture="ia64",publicKeyToken="6595b64144ccf1df",type="win32",version="6.0.0.0" could not be found. Please use sxstrace.exe for detailed diagnosis

And it’s occurring at about 00:30 every day, it seems to be caused by the scheduled task ProgramDataUpdater. It looks like it’s choking on the ia64 binary, and if you don’t need the Itanium version you could resolve it by renaming or deleting the exe, similar to this KB article:

http://support.microsoft.com/kb/2021839

.net 4 C# Parallel Array Bounds Checking

2010-03-24T20:48:00.001Z

In previous versions of .net (x64 .net 2), as a result of experimenting with the profiler and forming beliefs (whether true or false :-) that:

property accesses are expensive

bounds checks are not eliminated for static member arrays (this one was correct, as Greg Young proves).

parallel array accesses do not have the bounds checks optimized away

So, for consistency, I always wrote loops like this, with a local reference to the array and a variable in the loop scope holding the end limit.

int z = 0;

var localArray1 = memberArray1;

var localArray2 = memberArray2;

for (int x = 0, length = localArray1.Length; x < length; x++)

    z += localArray1[x] + localArray2[x];

Recently, I re-examined this practice with Visual Studio 2010 RC and the disassembly window. I wanted to find out what the best pattern would be consistency and allowing the JIT to hoist the bounds checks, eliminating them from the per-iteration part of the loop.

.net 2

x86 and x64 JITs were both unable to remove the bounds checks.

Rewriting the for loop to read

    for (int x = 0; x < localArray1.Length; x++)

Allowed the x86 JIT to eliminate one of the bounds checks. The x64 JIT still had both.

.net 4

The x86 JIT still had both bounds checks. The x64 JIT eliminated one.

Rewriting the for loop to read

    for (int x = 0; x < localArray1.Length; x++)

The x86 now had only one bounds check. The x64 eliminated both.

Conclusions

Don’t use a local variable to hold your array stopping condition.

Experiment with both ‘Any CPU’ and ‘x86’ if possible.

Check out the disassembly (step-by-step explanation by Vance Morrison).

Copying a Folder to and from Windows with rsync

2010-03-01T17:01:00.001Z

Suppose you’ve got a NAS, or *nix box which has an rsync daemon running on it.

You’ve also got the convenient cwrsync bundle installed on your Windows box.

Now you want to be able to copy all the files in a folder on the windows box, say:

C:\foo\my spaced path\things

to and from the rsync module on your server.

To copy from the server to Windows

"c:\Program Files (x86)\cwRsync\bin\rsync.exe" -v -r -c rsync://@server/module /cygdrive/c/foo/"my spaced path"/things

This assumes the default installation path for cwrsync, you should drop the “ (x86)” if you’re not running on a 64-bit version of Windows.

The parameters include

-v for verbose
-c to always test file checksums rather than timestamps. If you’re happy that the timestamps are reliable, replace it with a –t to use (and copy) the timestamps.
-r for recursive.

The path on the Windows box has been munged to cygwin’s standards to look like a *nix path.

The slashes all go forwards
The /cygdrive/c is the equivalent of “C:”
Any directory names that have spaces need a quote around their name, not around the path as a whole.

The path to the server specifies the rsync protocol, and the server name and module (like a share name in Windows/Samba/CIFS). I’ve not shown any user or password specification.

To copy from Windows to the server

"c:\Program Files (x86)\cwRsync\bin\rsync.exe" -v -c -r --no-perms --chmod=ugo=rwX /cygdrive/c/foo/"my spaced path"/things/ rsync://@server/module

Note the trailing slash after the Windows folder name. Without that, you’ll get a subfolder called “things” created under the module on your server.

I added the no-perms and chmod parameters because otherwise the ACLs that rsync placed on the copied files gave no rights to anyone.

MP3s Are Killing Home Taping

2010-01-12T21:08:00.001Z

Just try giving a friend a C90 and asking them to copy a couple of albums for you.

Silverlight 3 RIA Services Without Entities (POCO) – Part 1

2009-12-02T17:07:00.001Z

(I’m including Part 1 in the title because there’s a possibility I’ll be adding to this topic.)

If you look for information about using Plain Old CLR Objects with RIA services (or using RIA services without Linq to Entities) you’ll see a few articles telling you how easy it is to use your own business objects from a DomainService - If you simply stick the [Key] attribute above a property that uniquely identifies your object, all will be well.

Except it’s not necessarily true. It all depends on how ‘smart’ your objects are, and how you expect it to work. If you have the (accurate) mental model of the objects being serialized and deserialized between client and server then you’re probably going to be OK.

On the other hand, if you’re working with less dumb objects that do more than just hold database fields, and you think of the RIA services as more like remoting then, like me, you’re going to be disappointed.

To be honest, my first clue should have been that everything has to be get/set and the classes need parameterless constructors. My ‘business objects’ had some internal state that they used to map themselves back to the database, so I marked that with [Exclude] attributes.

I tried sending these objects to the client via a query method, and then accepting them back to the server as parameters on an [Invoke] method. All the internal state had gone. But that was because they weren’t the same objects I returned from the query, they were newly constructed objects with the same values in their public properties.

The lesson was that there’s no reference tracking going on between client and server. If you send the client an object, it will be cloned on the client side. If that object is modified and passed back, the server gets a new object with all the values – not the original object with new values applied.

This probably seems obvious to many people, particularly those who have used similar frameworks (like the view model stuff in ASP.NET MVC) but it’s not something I saw explicitly called out in any of the explanations of using Silverlight RIA services with POCO.

Connecting Android Phone to 2 Google Accounts (update)

2009-10-15T15:00:00.001+01:00

Original article here

Recently, Google announced that they now support email over ActiveSync. So in theory you could set the phone to get email, calendar and contacts via ActiveSync and not use IMAP for email.

I tried setting this up, but found the email part of ActiveSync to be unreliable (at least with my “Google apps for your domain” account) – it complained about keys and lost the email from the phone’s inbox.

To be fair, they’re targeting the ActiveSync support at the iPhone and Windows Mobile, not Android.

Perhaps reliability will improve when the system has been running a bit longer, it would be nice not to have to use IMAP and ActiveSync to access the second Google account.

Connecting an Android Phone to 2 Google Accounts

2009-08-26T09:17:00.001+01:00

If you’ve got an Android phone, and you want to get your contacts, email and calendar from two Google accounts (e.g. work and home) it’s possible but a bit clunky.

Set up the phone with the Google account you want to use most, this will be the account that the phone’s built-in Google apps will use. Note that if you change your mind about which account this should be you’ll need to reset you phone and so lose all your settings.

For the other account, add an Exchange/ActiveSync account for the server m.google.com (as if you were using Windows Mobile, as shown here) and set it to sync calendar and contacts (not email because Google sync currently support it). To pick up email, add an imap account as shown here.

Now your contacts and calendar entries that came from the main Google account will show up as from “Google” and the items from the second account will show up as “Exchange”.

Not perfect, but it works OK. Now I just need to figure out how to stop it from listing all the ActiveSync’d contacts in “lastname, firstname” format.

Also note that either of these Google accounts can be Google Apps For Your Domain (gafyd) accounts if imap and sync are enabled by your domain administrator.

Building a Network Cable Without a Crimp Tool

2009-06-03T12:57:00.001+01:00

Searching the net to find out if it’s possible to make a cable without an RJ45 crimp tool yielded lots of people saying it’s not practical.

If you’ve only got a couple of ends to fit and don’t mind wasting a connector (or two) it’s not that bad.

Just splay the inner cores of the cable in the correct order and cut straight across the ends. Then feed the cores into the plug (making sure they go down to the ends of the correct holes). While keeping the wires pushed firmly into the plug, push down each metal piece in turn with a small flat-blade screwdriver.

Finally, give the cable a half-hearted tug to make sure they’re all fairly firmly stuck.

Obviously a crimp tool would give a much more reliable result, but at a push…

Getting the Original Location of an Assembly’s Shadow Copy

2009-05-19T10:58:00.001+01:00

If a test framework has loaded a shadow copy of your test assembly, and you need the path it was built to, you can use the following:

            var codebase = new Uri(Assembly.GetExecutingAssembly().CodeBase);

            var assembly = new FileInfo(codebase.LocalPath);

Assembly.Load C++ CLI assembly gives Unverifiable code failed policy check

2009-04-29T14:08:00.001+01:00

This is one of those problems that I couldn’t find the answer with google.

Trying to load a C++ mixed mode assembly (like a CLR class library) from a byte array instead of a file throws a FileLoadException.

            // ClassLib.dll is a mixed-mode assembly (from a C++ CLR Class Library project
 
            Assembly.Load("ClassLib"); // Works
 
            using (var stream = new FileStream("ClassLib.dll", FileMode.Open, FileAccess.Read))
            {
                var bytes = new byte[stream.Length];
                stream.Read(bytes, 0, bytes.Length);
 
                Assembly.Load(bytes); // System.IO.FileLoadException "Unverifiable code failed policy check. (Exception from HRESULT: 0x80131402)"
            }

Mock and Stub for Linq To Sql

2009-04-28T10:00:00.001+01:00

All the information I could find on testing Linq to Sql (DLinq) followed one of the following approaches:

Using reflection to hack the internals of System.Data.Linq
Duplicating the database (e.g. to Sql Compact Edition)
Using the real database with rollback attributes on the test
Writing the linq code against a ‘repository’ rather than the designer-generated classes.

Here’s a way to mock the tables so that the linq to sql code can be tested against in-memory tables.

For the example code below, I’m using a dbml-generated DataContext which contains a reference to the Regions table of the Northwind database.

The wizard-generated code looks like this:

    [System.Data.Linq.Mapping.DatabaseAttribute(Name="Northwind")]
    public partial class MyDataDataContext : System.Data.Linq.DataContext
    {
       …
        public System.Data.Linq.Table<Region> Regions
        {
            get
            {
                return this.GetTable<Region>();
            }
        }
    }

And the method I want to test looks like this:

        public void DataAccess()
        {
            var context = new MyDataDataContext();
 
            var max = context.Regions.Max(r => r.RegionID);
            context.Regions.InsertOnSubmit(new Region { RegionID = max + 1, RegionDescription = "New region" });
 
            context.SubmitChanges();
        }

So first, create an interface to replace the use of MyDataDataContext. Here is an IMockableDataContext which describes the methods you might need from System.Data.Linq.DataContext:

    public interface IMockableDataContext : IDisposable
    {
        void SubmitChanges();
    }

Add IMyDataContext which describes the table properties, they are copied from the designer-generated MyDataContext, but the return types are changed to use IMockableTable instead of System.Data.Linq.Table:

    public interface IMyDataContext : IMockableDataContext
    {
        IMockableTable<Region> Regions { get; }
    }

IMockableTable is based on ITable and IQueryable<TEntity>, the same as System.Data.Linq.Table – so any code using the Regions property should work fine if the types are defined using ‘var’:

    public interface IMockableTable<TEntity> : ITable, IQueryable<TEntity>
    {
    }

IMockableTable is implemented by a wrapper class MockableTable. It can be constructed from either an object which implements ITable and IQueryable<TEntity> (like an instance of System.Data.Linq.Table) or from two separate objects (like a mocked ITable and an in-memory collection). All its members call into the object(s) supplied in the constructor.

    public class MockableTable<TEntity> : IMockableTable<TEntity>
    {
        private readonly ITable table;
        private readonly IQueryable<TEntity> queryable;
 
        public MockableTable(ITable table, IQueryable<TEntity> queryable)
        {
            this.table = table;
            this.queryable = queryable;
        }
 
        public MockableTable(ITable table)
            : this(table, (IQueryable<TEntity>)table)
        {
        }
 
        public IEnumerator<TEntity> GetEnumerator()
        {
            return queryable.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)queryable).GetEnumerator();
        }
 
        public Expression Expression
        {
            get { return queryable.Expression; }
        }
 
        public Type ElementType
        {
            get { return queryable.ElementType; }
        }
 
        public IQueryProvider Provider
        {
            get { return queryable.Provider; }
        }
 
        public void InsertOnSubmit(object entity)
        {
            table.InsertOnSubmit(entity);
        }
 
        public void InsertAllOnSubmit(IEnumerable entities)
        {
            table.InsertAllOnSubmit(entities);
        }
 
        public void Attach(object entity)
        {
            table.Attach(entity);
        }
 
        public void Attach(object entity, bool asModified)
        {
            table.Attach(entity, asModified);
        }
 
        public void Attach(object entity, object original)
        {
            table.Attach(entity, original);
        }
 
        public void AttachAll(IEnumerable entities)
        {
            table.AttachAll(entities);
        }
 
        public void AttachAll(IEnumerable entities, bool asModified)
        {
            table.AttachAll(entities, asModified);
        }
 
        public void DeleteOnSubmit(object entity)
        {
            table.DeleteOnSubmit(entity);
        }
 
        public void DeleteAllOnSubmit(IEnumerable entities)
        {
            table.DeleteAllOnSubmit(entities);
        }
 
        public object GetOriginalEntityState(object entity)
        {
            return table.GetOriginalEntityState(entity);
        }
 
        public ModifiedMemberInfo[] GetModifiedMembers(object entity)
        {
            return table.GetModifiedMembers(entity);
        }
 
        public DataContext Context
        {
            get { return table.Context; }
        }
 
        public bool IsReadOnly 
        { 
            get { return table.IsReadOnly; }
        }
    }

So that MyDataContext can be treated as an IMyDataContext, we can take advantage of the partial declaration of MyDataContext and add an extra partial declaration which includes the explicit implementation of IMyDataContext to create a MockableTable wrapper for the Regions table.

    public partial class MyDataDataContext : IMyDataContext
    {
        IMockableTable<Region> IMyDataContext.Regions
        {
            get
            {
                return new MockableTable<Region>(Regions);
            }
        }
    }

The last stage in fitting the interfaces to the code is to modify the method to be tested:

        public void DataAccess()
        {
            var context = new MyDataDataContext();
            AddNewRegion(context);
        }
 
        public void AddNewRegion(IMyDataContext context)
        {
            var max = context.Regions.Max(r => r.RegionID);
            context.Regions.InsertOnSubmit(new Region { RegionID = max + 1, RegionDescription = "New region"});
 
            context.SubmitChanges();
        }

And now a test can be written (here I’m using NUnit and Moq):

        [Test]
        public void TestAddNewRegion()
        {
            var mockRegionTable = new Mock<ITable>();
            var mockRegionData = new[] { new Region { RegionID = 5, RegionDescription = "Here" }, new Region { RegionID = 9, RegionDescription = "There" } };
            var mockRegions = new MockableTable<Region>(mockRegionTable.Object, mockRegionData.AsQueryable());
            var mockContext = new Mock<IMyDataContext>();
            mockContext.SetupGet(c => c.Regions).Returns(mockRegions);
 
            var data = new DataClass();
            data.AddNewRegion(mockContext.Object);
 
            mockRegionTable.Verify(x => x.InsertOnSubmit(It.Is<Region>(r => r.RegionID == 10 && r.RegionDescription == "New region")));
            mockContext.Verify(c => c.SubmitChanges());
        }

It’s a fair bit of code, but most of it is a one-off:

IMockableDataContext and (I)MockableTable are reusable.
Adding tables to MyDataContext requires updating IMyDataContext and the partial declaration of MyDataContext.
Future mockable data contexts need a new IFooDataContext and partial declaraion of FooDataContext

Any comments, criticisms or suggestions for improvements are welcome!