Even so, over the past 6 years or so, as we’ve added features and fixed bugs we’ve diligently been adding tests. We’ve now got to the stage where we’ve got thousands of unit tests and hundreds of integration tests. For some products, the size of the test code exceeds the product code, admittedly not to the scale of Sqlite though.

To do this effectively, we’ve adopted check as our unit test framework and have incorporated the validating mock library from cgreen as well as our own mock JVM implementation that performs validation over the JNI interface. We’ve even changed our coding style, changing it so that the links between compilation units can be replaced at run time allowing release binary testing which is a huge confidence boost over the traditional C testing method of producing an individual binary for testing each compilation unit.

Testing the Released Binary

Testing the released binary is a neat idea (subject to usual caveats of how to obtain coverage) – it means that you’re delivering to your end user compiled code that has actually been executed and tested as opposed to trusting the compiler not to change something between the test compile and the release compile (or more likely, some preprocessor macro changing the code path). Testing the release binary is something that we do with our .NET and Java products and so it would be great if we could do the same thing with our C products without needing to rewrite them all.

Coming across TypeMock which promises this functionality for Windows led me to think about how you could achieve the same thing on a Linux system and integrate it into the rest of our test tools.

What you need to do may be inherently non-portable and given that we need to build for so many platforms it may not be something that we pursue, but it’s an interesting thought exercise. So here are my thoughts on the ways it could be implemented.

The high level concepts that we need when testing on a release binary involve overriding the implementation with mocks and trapping changes to any global variables. Since we’ve already got a mock framework we can call that when we’ve performed the appropriate traps.

My initial thoughts were around manipulating the ELF relocations in the binary to point to mock functions, however I suspect that for running multiple test cases the overhead of reloading the binary and performing the manipulations may be excessive.

My current thoughts are revolving using the functionality present in gdb. With gdb you can trap access to global variables using watches and stop execution using breakpoints. If we can intercept these traps and call our mocks we’ve achieved our aim. The functionality of adding breakpoints and watches appears to be exposed in libgdb which means that we should be able to do this in a portable way.

Performing unit testing on the release binary opens up a new range of testing strategies and would allow the testing of legacy code which is usually considered unviable for testing. Once the test coverage is in place, the code can be safely refactored to a more testable design.

Should I get a chance to try out this technique, I’ll report back, hopefully with an open source project for all to use.

The goal of Silverlight is to provide a consistent experience across desktop and mobile phones. Developers will be able to easily optimize Silverlight applications for mobile form factors or run existing Silverlight applications on mobile phones.

The great thing about this release is that any existing Silverlight applications should work on any mobile device with Silverlight installed. The question about this is that if you design a user interface for a desktop browser how will it fit on a windows mobile browser? Well, Microsoft plan to give developers the ability to “optimize Silverlight applications for mobile form factors” which sounds like they will give us a way of dealing with the obvious UI differences between desktop and mobile platforms, as well as the underlying runtime issues.

We’ve already blogged about what impact Silverlight may have on single dealer portals. I’m really excited to see what developers can do using StreamLink for Silverlight to enable the real-time web on a windows mobile device. What opportunities might Streamlink for Silverlight Mobile enable?

Silverlight for Mobile

Read the Silverlight for Mobile FAQ for more information.

The RTD interface is small (6 methods) and Kenny Kerr has a great series of articles about RTD on his blog so I won’t repeat that information here and instead concentrate on integration to StreamLink.NET and pulling in real time data from a Caplin platform deployment.

The following walkthrough is a short example of how to do this, there’s no error checking, logging and certainly the example is nowhere near production quality, however it does demonstrate that linking up Excel and data from the Liberator is straightforward.

ServerStart is the entry point and in here we can instantiate StreamLink.NET and setup a map between the RTD topic ids and the Subject/Field information.

    public int ServerStart(IRTDUpdateEvent callback)
    {
        sl = new StreamLinkInterop();
        m_callback = callback;
        m_timer = new Timer();
        m_timer.Tick += new EventHandler(TimerEventHandler);
        m_timer.Interval = 1000;
        m_topics = new Dictionary<int, KeyValuePair<string,string>>();
        return 1;
    }

The ConnectData method validates the arguments passed through and then attempts to subscribe to the data:

public object ConnectData(int topicId,
                              ref Array strings,
                              ref bool newValues)
    {
        if (2 != strings.Length)
        {
            return "Subject and field is required";
        }

        string subject = strings.GetValue(0).ToString();
        string field = strings.GetValue(1).ToString();

        m_topics[topicId] = new KeyValuePair(subject, field);
        m_timer.Start();
        sl.Subscribe(subject, field);
        return "NO_DATA_YET";
    }

And DisconnectData will unsubscribe:

    public void DisconnectData(int topicId)
    {
        KeyValuePair pair = m_topics[topicId];

        sl.Unsubscribe(pair.Key, pair.Value);
        m_topics.Remove(topicId);
    }

RefreshData will retrieve the current image for the subscribed data:

    public Array RefreshData(ref int topicCount)
    {
        object[,] data = new object[2, m_topics.Count];

        int index = 0;

        foreach (int topicId in m_topics.Keys)
        {
            data[0, index] = topicId;
            KeyValuePair pair = m_topics[topicId];
            data[1, index] = sl.GetData(pair.Key, pair.Value);

            ++index;
        }

        topicCount = m_topics.Count;

        m_timer.Start();
        return data;
    }

Because Excel polls for the data we’ve got to have a cache within our RTD server so that data is available when Excel calls in, for the purposes of this exercise we’re only considering Record data without market depth or history so our cache can be really simple:

    public class RecordType1Cache
    {
        Dictionary fieldMap = new Dictionary();

        public RecordType1Cache()
        {
        }

        public void Update(IRecordEvent evt)
        {
            foreach ( IField field in evt.Fields.Values )
            {
                fieldMap[field.Name] = field.Value;
            }
        }

        public string GetFieldValue(string fieldName)
        {
            if (fieldMap.ContainsKey(fieldName))
            {
                return fieldMap[fieldName];
            }
            return "NO_FIELD_AVAILABLE";
        }
    }

The only missing part is the StreamLinkInterop class which integrates with StreamLink, this needs to implement the public methods we saw earlier: Subscribe, Unsubscribe and GetData as well as the IRecordSubscriptionListener interface from StreamLink.NET since we want to receive record updates. When an update is received we put it into our cache and return immediately.

There’s a couple of maps which allows finding the RecordType1Cache object from both the StreamLink side (using the IRecordSubscription as the key) and from the RTD side (using a subscription name as the key).

The connection to the server is setup in the constructor for code simplification purposes. The servername is hard coded so you’ll probably need to change it or find a way to configure it if you use this code as a base for your own project.

    public class StreamLinkInterop : IRecordSubscriptionListener
   {
        StreamLink myStreamLink;
        Dictionary cache = new Dictionary();
        Dictionary subscriptionLookup = new Dictionary();

        public StreamLinkInterop()
        {
            IStreamLinkConfiguration config = SimpleConfiguration.CreateType2Connection("liberator", 8080);
            myStreamLink = new StreamLink(config);
            myStreamLink.CredentialsProvider = new PasswordCredentialsProvider("admin", "admin");
            myStreamLink.StreamLinkProvider.Connect();
        }

        public void Terminate()
        {
            myStreamLink.StreamLinkProvider.Disconnect();
        }

        public void Subscribe(string subject, string field)
        {
            string name = subject + ";" + field;

            IRecordSubscriptionParameters rparams = myStreamLink.StreamLinkProvider.ParametersFactory.CreateRecordSubscriptionParameters(new string[] { field } );
            ISubscription sub = myStreamLink.StreamLinkProvider.CreateRecordSubscription(this, subject , rparams);

            cache[sub] = new RecordType1Cache();
            subscriptionLookup[name] = sub;
            sub.Subscribe();
        }

        public void Unsubscribe(string subject, string field)
        {
            string name = subject + ";" + field;

            if (subscriptionLookup.ContainsKey(name))
            {
                ISubscription sub = subscriptionLookup[name];
                sub.Unsubscribe();
                cache.Remove(sub);
                subscriptionLookup.Remove(name);
            }
        }
       public string GetData(string subject, string field)
        {
            string name = subject + ";" + field;
            if (subscriptionLookup.ContainsKey(name))
            {
                ISubscription sub = subscriptionLookup[name];
                return cache[sub].GetFieldValue(field);
            }
            return "UNKNOWN+SUBJECT";
        }

        #region IRecordSubscriptionListener Members

        public void RecordType2Updated(Caplin.StreamLink.Subscription.ISubscription subscription, IRecordType2Event ev)
        {
        }

        public void RecordType3Updated(Caplin.StreamLink.Subscription.ISubscription subscription, IRecordType3Event ev)
        {
        }

        public void RecordUpdated(Caplin.StreamLink.Subscription.ISubscription subscription, IRecordEvent ev)
        {
            if (cache.ContainsKey(subscription))
            {
                cache[subscription].Update(ev);
            }
        }

        #endregion

        #region ISubscriptionListener Members

        public void SubscriptionErrorReceived(Caplin.StreamLink.Subscription.ISubscription subscription, Caplin.StreamLink.Subscription.ISubscriptionErrorEvent ev)
        {
        }

        public void SubscriptionStatusUpdated(Caplin.StreamLink.Subscription.ISubscription subscription, Caplin.StreamLink.Subscription.ISubscriptionStatusEvent ev)
        {
        }

        #endregion
    }

To pull data into excel into excel use a formula along the following lines: =RTD("com.caplin.excel",,"/I/MSFT.O", "BID"). The data in the cell will update periodically (by default every 2000ms). This period can be changed using either a registry setting or using VBA, details can be found at MSDN.