{"id":3653,"date":"2013-03-19T16:15:49","date_gmt":"2013-03-19T23:15:49","guid":{"rendered":"http:\/\/blog.xamarin.com\/?p=3653"},"modified":"2019-07-03T10:13:06","modified_gmt":"2019-07-03T17:13:06","slug":"producing-better-bindings-for-xamarin-ios-and-xamarin-mac","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/xamarin\/producing-better-bindings-for-xamarin-ios-and-xamarin-mac\/","title":{"rendered":"Producing Better Bindings for Xamarin.iOS and Xamarin.Mac"},"content":{"rendered":"

\t\t\t\tFor .NET developers with some knowledge of Objective-C, writing .NET bindings for Objective-C libraries is not very hard. It is well documented<\/a> and several complete examples<\/a> are available to guide you.<\/p>\n

Still, the process can be quite error-prone. Many typos and mistakes will only be caught at runtime and only when you use the specific API affected. Due to those issues, many bugs won’t be found for days, months or even years after you released your bindings.<\/p>\n

Full test coverage would considerably reduce the number of bugs\u2014but it would require 2x-5x time to create the bindings. That might not be the best way to invest your time into a project. Fortunately, the Objective-C runtime<\/a> has introspection APIs available, even if limited compared to .NET. That makes it possible to run generalized test cases without knowing the purpose for which the bindings were intended.<\/p>\n

This blog series will go through different test fixtures to help test Xamarin.iOS<\/a> or Xamarin.Mac<\/a> Objective-C bindings. With a bit of customization (you need to inherit from them and override a few methods) you will be able to spot some of the most common binding mistakes. While this is not a pain-free approach, you should be able find a lot of bugs in a very short amount of time.<\/p>\n

Basics<\/strong><\/p>\n

All the test fixtures inherit from a single base class: ApiBaseTest.cs<\/code><\/a>. It defines an Assembly<\/code> property that you’ll need to override to point to your binding assembly. E.g. to test the Cocos2D bindings<\/a> you would need this piece of code:<\/p>\n

\nprotected override Assembly Assembly {\n     get { return typeof (CCAccelAmplitude).Assembly; }\n}\n<\/pre>\n
This base fixture also allow us to cheat<\/em> a bit by introducing two properties that you should, when you start<\/strong> testing, set to true<\/code> in your own inherited fixtures. Once every failure has been fixed it’s safe to turn them off\u2014and let the test fixtures behave like any others.<\/p>\n
ContinueOnFailure = true;<\/code><\/strong><\/p>\n
This property will avoid stopping the test execution when failing an assertion. Doing otherwise would require too many “build \/ run \/ debug” cycles to go through dozens (or thousands) of types, methods or parameters. You’ll often be able to fix several issues between builds, progressing a lot quicker toward your goal.<\/p>\n
LogProgress = true;<\/code><\/strong><\/p>\n
It’s likely you’ll hit bugs that will crash your testing process\u2014for example, a bad API signature can corrupt the stack. When that occurs, you want to know what was being executed. Turning on the LogProgress<\/code> property will give you this information (and a lot of lines in your console).<\/p>\n
Even with those properties to help you, there will be failures that require a bit more knowledges to solve\u2014ways to ignore (special cases) or when the test fixture requires a bit of extra help to get the most of out them. To help you get down to zero failures, each test fixture will be documented in it’s own blog entry. Stay tuned for the rest of the series!<\/p>\n
Read the rest of the series:<\/b><\/p>\n