![\"grannyschindler\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/GrannySchindler.jpg\")
<\/a><\/p>\nMeet late Grandma Grete Schindler. I’d like to introduce you to my grandma, because this post will be about the essence and purpose of unit testing in Visual Basic, and Granny Grete basically invented the concept of unit testing. Yes, she really did, I kid you not \u2013 she was a very wise woman! When she saw someone in our family doing their work in a hectic rather than a thoughtful way, she always quoted her most favorite Silesian proverb: \u201cKinder, schmei\u00dft nicht mit dem Hintern um, was ihr m\u00fchsam mit den H\u00e4nden aufgebaut habt\u201d \u2013 which roughly translates to \u201cKids, do not push over with your behinds, what you build so arduously with your hands!\u201d. Well, and that\u2019s actually quite simple to understand, is it not? \u2013 Just think of building a sandcastle: You can spend so much effort to build that, and it takes just one misstep to ruin the work of hours.<\/p>\n
Doesn\u2019t that also ring a bell when it comes to software development? Especially with large code base software projects, and especially when you and your team need to develop and maintain that over a really long period of time? When a customer calls you and claims to have found a bug, according to that bug\u2019s severity, you will most likely act very, very quickly! Depending on the customer and how mission critical their application is, you may as well act a little frantically or even stressed out. And probably you let yourself be carried to do some imprudent code patches, you would never have done, had you taken some time and kept your cool! And, yes, you fixed the bug with those code edits comparatively quickly. But at the same time, with the code you patched, you changed another behavior in a totally unrelated situation as well, and you are completely unaware of that fact\u2013either because you wrote the code a long time ago, and cannot remember \u201cwhat else it did\u201d, or you did not write the code yourself at all! You just broke the code by fixing a bug. You remember that Facebook meme: \u201cHalf a year ago, only God and I knew what this code did. Now, only God knows!\u201d Doesn\u2019t that sound familiar? Well, that is exactly what Granny Schindler always warned us about: we\u2019re improving here and breaking there. Unit tests prevent that. They are your watchdogs, so that premature code edits like that are becoming more and more unlikely to happen, the higher the coverage of your code base by unit test (watchdog) code becomes.<\/p>\n
On top\u2013know this: Introducing unit tests to your projects can have another very positive effect: Unit tests can considerably<\/i> speed up your turnaround times with that ongoing cycle “code edit, compile, deploy, debug, code edit, compile\u2026”: Imagine, you have a huge WPF, UWP or ASP.NET solution with tens of libraries, a login procedure, a complex database in the backend, thus with a startup time of about 30 to 60 seconds. When you\u2019re developing a certain algorithm, you need to restart that app countless times, and you\u2019re wasting a lot of time with starting it up, logging on, navigating to the function you are currently implementing and only then<\/i> testing the code you just wrote. In total, it can easily take you 2 minutes to find the right spot to debug. Do that as often as 30 times a day, and you already lost a full hour just for waiting for your app to come up. So, let\u2019s take a look at this first aspect of unit testing, speeding up your development turnaround cycles.<\/p>\nSpeed up your turnaround times with Unit Testing<\/h2>\n
Let\u2019s develop a little UWP App, which converts decimal integer numbers to Roman numerals. An app, with which you type in ‘1234’, and out comes that value with the roman representation in the form of ‘MCCXXXVI’. Let\u2019s do this, and let\u2019s fire up Visual Studio 2017!<\/p>\n
- \n
- \n
- \n
- Create a new Universal Windows App by picking New<\/i> and Project<\/i> from the File<\/i> menu. In the dialog Visual Studio shows now, find the section Visual Basic<\/i> and Universal Windows<\/i>. From the templates, pick Blank App (Universal Windows)<\/i>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"01_createnewuwpproject\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/01_CreateNewUwpProject-1024x626-8.png\")
<\/a><\/p>\n- \n
- \n
- \n
- Visual Studio asks you, what versions of Windows 10 you want to target. In this example, we go with the latest Windows 10 version \u2013 but since we do not need the latest Windows 10 functionality for this example, the version at this point does not really matter.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
<\/a><\/p>\n
- \n
- \n
- \n
- If you never created an UWP app with Visual Studio on your developer machine, you need to bring Windows 10 into the so-called developer mode<\/i>. Usually, Windows 10 protects you against viruses and other malicious code by only allowing apps from the Windows Store to be installed on your machine. You have to loosen these constraints slightly to deploy a Windows 10 App which you\u2019re developing directly to your machine from within Visual Studio. So, in the dialog, which Windows shows now, allow your machine to be set to the developer mode.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"03_a_enabledevelopermode\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/03_a_EnableDeveloperMode-8.png\")
<\/a><\/p>\n- \n
- Let\u2019s quickly design the UI. In UWP apps, as you probably know, we do this in XAML. I don\u2019t want to address XAML here in more detail \u2013 that would be way beyond the scope. So, to get quick results for the demo, just copy the following Gist code, double-click MainPage.xaml<\/i> in the solution explorer to open it, and simply replace the existing XAML Code by pasting it over.\n<\/i><\/li>\n<\/ul>\n
As you will see in a couple of seconds: We did not program much yet, we just designed the UI. Still, we can start our app already, so let\u2019s do this, and this is where you instantly spot a problem: A UWP app needs to be deployed every time you worked on its code and restart it, so the turnaround times even on fast machines are considerable. And this is \u201conly\u201d a UWP app which does not have any substantial code yet! When you\u2019re developing a Xamarin Forms App, for example, and you need to deploy to an iOS or Android emulator, turnaround times can be even worse \u2013 the same applies for ASP.NET projects!<\/p>\n
So, let\u2019s do something about that:<\/p>\n
NOTE: For this sample, we use Visual Studio 2017 Update 3 (actually, only the first Preview of Update 3<\/a> is the current version, while these lines are being written). Update 3 introduces .NET Standard and .NET Core for Visual Basic. You can also use Visual Studio 2017 with an earlier version, but for the following steps, you would alternatively need to create a Portable Class Library<\/i> project in step 2, for which you should choose all available target platforms.<\/p>\n
![\"04_a_addingnetstandardproject\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/04_a_AddingNetStandardProject-8.png\")
<\/a><\/p>\n- \n
- \n
- \n
- In the solution explorer, add a new project to your solution by bringing up the context menu of the solution\u2019s main node, and clicking Add new project<\/i>. When Visual Studio shows the Add New Project<\/i> Dialog, from the Visual Basic<\/i> section pick Class Library (.NET Standard)<\/i>. Name the new Project RomanNumeralsLib<\/i>. Since there are several types of class libraries project templates, make sure, you got the right one (.NET Standard)<\/i>. Click OK<\/i>, to add the project.<\/li>\n
- As the name implies, .NET Standard is not really a new platform. Rather, a .NET Standard library project defines a standard which makes sure that the code uses only a certain set of APIs, so a project type, which agrees to it, guarantees to have available all the APIs according to that standard. In our sample, we\u2019re using an UWP project. At the time, UWP only supports .NET Standard up to version 1.6; if you create a new .NET Standard library project, however, its version is set to 2.0 by default. It\u2019s good to know though, that a .NET Standard library makes real sense when it can be used on multiple platforms. Even this does not apply to our example, but if you wanted our library to be used on Android or iOS in Xamarin projects as well, you would need to find the highest .NET Standard version, which is supported by all the target platforms \u2013for Android, iOS and UWP Apps that would currently be .NET Standard 1.4. Let\u2019s pick this version by setting the target framework with the project\u2019s properties dialog, which you can show via the project\u2019s context menu in the solution explorer, and clicking Properties<\/i>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"04_b_pickstandardversion\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/04_b_PickStandardVersion-8.png\")
<\/a><\/p>\n- \n
- \n
- \n
- And while we\u2019re at it, let\u2019s also add yet another project: the actual unit test project. You integrate a unit test in your solution by adding a related Unit Test<\/i> Project<\/i> to it. If you want to unit-test the code of a library, you need a Unit Test<\/i> Project<\/i>, which can consume that library. If you want to unit-test the code of a UWP app, you need an additional Unit Test<\/i> Project (Universal Windows)<\/i> in your solution. But pick wisely! A UWP unit test takes almost as much time to start as a simple UWP app does. In most cases, the actual code to test will not at all be in the UWP app, but in a library\u2013as in our case. This is the reason, that even though we have a UWP app, we add a Unit Test Project (.NET Framework)<\/i> to our solution, and not<\/i> one of type Unit Test Project (Universal Windows)<\/i>!<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"06_addingunittestproject\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/06_AddingUnitTestProject-8.png\")
<\/a><\/p>\n- \n
- \n
- \n
- Before we start unit testing, let\u2019s have something to<\/i> test! First, let\u2019s make the library accessible in our UWP app and also from the unit test project by adding the necessary references. For this to end, in the solution explorer find the branch References<\/i> of the project RomanNumeralsUnitTest<\/i>, from the context menu pick Add Reference<\/i>, and check the project RomanNumeralsLib<\/i> in the dialog, which Visual Studio shows now.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"07_addingreferences\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/07_AddingReferences-8.png\")
<\/a><\/p>\n- \n
- \n
- \n
- IMPORTANT:<\/strong> Don\u2019t forget to add the same reference in the UWP project RomanNumerals (Universal Windows)<\/i>!<\/li>\n
- Now, let\u2019s do some coding. In the Project RomanNumeralsLib<\/i>, replace the code of Class1.vb<\/i> by the following code, and rename the file to RomanNumerals.vb<\/i><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
.<\/p>\n
- \n
- \n
- \n
- This will be our primary subject to unit testing. Let\u2019s do this now: Bring up the file UnitTest1.vb<\/i> from the project RomanNumeralUnitTest<\/i>.<\/li>\n
- What you see here is the basic stub for a unit test class and a unit test method. Unit test classes are annotated by the TestClass<\/i> attribute, while a unit test method is tagged with the TestMethod<\/i> attribute. If you do not annotate test classes and test methods with those attributes, they cannot be discovered. Let\u2019s replace the content of that file with our first test method. Just copy the code from the following Gist snippet to your code file:<\/li>\n
- The key code line at this point is the method Assert<\/i>: When the test method Test1to20<\/i> runs, Assert<\/i> provides a series of methods to ensure a certain behavior of the tested code. In our example, we\u2019re using Assert\u2019s AreEqual<\/i> method, which tests if the expected first parameter equals the value of the second parameter. If it does, the check passes, otherwise, it fails and with it, the whole test fails. Since the second parameter is the return value of the method we\u2019re actually testing, this test asserts for the future, that this method always works as expected. And this is basically, how unit tests methods are being written!<\/li>\n
- Now, to actually run this unit test, we do not<\/i> need to start our app. We control the execution of the various test classes and test methods with the Test Explorer<\/i> tool window, which you can show by clicking Windows\/Test<\/i> Explorer from the Test<\/i> menu. When you now rebuild the Solution, you should see your first Test in the Test Explorer. Take a look at the following animated GIF, which shows you in details, how it\u2019s done:<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"08_firstunittestsmall\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/08_FirstUnitTestSmall-8.gif\")
<\/a><\/p>\n- \n
- Starting the test method now is simple. Just open the context menu for the Test1to20<\/i> test, and click either Run Selected Test<\/i> or Debug Selected Test<\/i>. With Run Selected Tests<\/i>, the method (or, if you select more than one test method once you got them, the methods<\/i><\/strong>) gets executed and tested. Alternatively, you can also Debug Selected Tests<\/i>, which allows you that breakpoints in the test methods and in the code that is being tested are considered. You can debug through the code as you would do it normally during a debug session.<\/li>\n<\/ul>\n
And here now is the first important takeaway: Compare the starting time of the test with the app\u2019s starting time. The test is firing up in not even a second while starting the app itself takes about 10-20 seconds \u2013 and we did not include any meaningful code in the UWP app, yet! Developing complex algorithms, which do not have dependencies to a UI or fixed data source like a database, are much easier, quicker and more durable to develop when using unit tests.<\/p>\n
Secure the code you wrote with unit tests<\/h2>\n
Now let\u2019s extend the unit test projects by a couple of additional test methods, which you can simply copy from the following Gist snippet into the UnitTest1.vb<\/i> file:<\/p>\n
When you recompile your solution and click on Run all<\/i> in the test explorer, you see this:<\/p>\n
![\"09_failedtests\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/09_FailedTests-8.png\")
<\/a><\/p>\nThe test explorer tells you, that the unit test method TestTensAndHunderds<\/i> has failed. And, according to the exception message text, the actual and the expected results were different. You can open the context menu of TestTensAndHunderds <\/i>now, and Debug the selected test. In that case, the debugger stops at the code line whose assert method caused the exception, which you see here:<\/p>\n
![\"10_failedtest\"](\"https:\/\/devblogs.microsoft.com\/vbteam\/wp-content\/uploads\/sites\/7\/2017\/05\/10_FailedTest-8.png\")
<\/a><\/p>\nWhen we look closer at the unit test code, we must admit that it looks absolutely OK: “XLIX” is<\/i> the roman numeral for 49. Which means: There must be a bug in our algorithm code, and \u2013 low and behold \u2013 if we look closer at the algorithm, we quickly find out, that there is a typo in the code line which defines all the existing letters for the roman numerals. So, let\u2019s see what happens when we correct that bug!<\/p>\n
- What you see here is the basic stub for a unit test class and a unit test method. Unit test classes are annotated by the TestClass<\/i> attribute, while a unit test method is tagged with the TestMethod<\/i> attribute. If you do not annotate test classes and test methods with those attributes, they cannot be discovered. Let\u2019s replace the content of that file with our first test method. Just copy the code from the following Gist snippet to your code file:<\/li>\n
- This will be our primary subject to unit testing. Let\u2019s do this now: Bring up the file UnitTest1.vb<\/i> from the project RomanNumeralUnitTest<\/i>.<\/li>\n
- Now, let\u2019s do some coding. In the Project RomanNumeralsLib<\/i>, replace the code of Class1.vb<\/i> by the following code, and rename the file to RomanNumerals.vb<\/i><\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- IMPORTANT:<\/strong> Don\u2019t forget to add the same reference in the UWP project RomanNumerals (Universal Windows)<\/i>!<\/li>\n
- \n
- Before we start unit testing, let\u2019s have something to<\/i> test! First, let\u2019s make the library accessible in our UWP app and also from the unit test project by adding the necessary references. For this to end, in the solution explorer find the branch References<\/i> of the project RomanNumeralsUnitTest<\/i>, from the context menu pick Add Reference<\/i>, and check the project RomanNumeralsLib<\/i> in the dialog, which Visual Studio shows now.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- \n
- And while we\u2019re at it, let\u2019s also add yet another project: the actual unit test project. You integrate a unit test in your solution by adding a related Unit Test<\/i> Project<\/i> to it. If you want to unit-test the code of a library, you need a Unit Test<\/i> Project<\/i>, which can consume that library. If you want to unit-test the code of a UWP app, you need an additional Unit Test<\/i> Project (Universal Windows)<\/i> in your solution. But pick wisely! A UWP unit test takes almost as much time to start as a simple UWP app does. In most cases, the actual code to test will not at all be in the UWP app, but in a library\u2013as in our case. This is the reason, that even though we have a UWP app, we add a Unit Test Project (.NET Framework)<\/i> to our solution, and not<\/i> one of type Unit Test Project (Universal Windows)<\/i>!<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- As the name implies, .NET Standard is not really a new platform. Rather, a .NET Standard library project defines a standard which makes sure that the code uses only a certain set of APIs, so a project type, which agrees to it, guarantees to have available all the APIs according to that standard. In our sample, we\u2019re using an UWP project. At the time, UWP only supports .NET Standard up to version 1.6; if you create a new .NET Standard library project, however, its version is set to 2.0 by default. It\u2019s good to know though, that a .NET Standard library makes real sense when it can be used on multiple platforms. Even this does not apply to our example, but if you wanted our library to be used on Android or iOS in Xamarin projects as well, you would need to find the highest .NET Standard version, which is supported by all the target platforms \u2013for Android, iOS and UWP Apps that would currently be .NET Standard 1.4. Let\u2019s pick this version by setting the target framework with the project\u2019s properties dialog, which you can show via the project\u2019s context menu in the solution explorer, and clicking Properties<\/i>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- In the solution explorer, add a new project to your solution by bringing up the context menu of the solution\u2019s main node, and clicking Add new project<\/i>. When Visual Studio shows the Add New Project<\/i> Dialog, from the Visual Basic<\/i> section pick Class Library (.NET Standard)<\/i>. Name the new Project RomanNumeralsLib<\/i>. Since there are several types of class libraries project templates, make sure, you got the right one (.NET Standard)<\/i>. Click OK<\/i>, to add the project.<\/li>\n
- \n
- Let\u2019s quickly design the UI. In UWP apps, as you probably know, we do this in XAML. I don\u2019t want to address XAML here in more detail \u2013 that would be way beyond the scope. So, to get quick results for the demo, just copy the following Gist code, double-click MainPage.xaml<\/i> in the solution explorer to open it, and simply replace the existing XAML Code by pasting it over.\n<\/i><\/li>\n<\/ul>\n
- If you never created an UWP app with Visual Studio on your developer machine, you need to bring Windows 10 into the so-called developer mode<\/i>. Usually, Windows 10 protects you against viruses and other malicious code by only allowing apps from the Windows Store to be installed on your machine. You have to loosen these constraints slightly to deploy a Windows 10 App which you\u2019re developing directly to your machine from within Visual Studio. So, in the dialog, which Windows shows now, allow your machine to be set to the developer mode.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- \n
- Visual Studio asks you, what versions of Windows 10 you want to target. In this example, we go with the latest Windows 10 version \u2013 but since we do not need the latest Windows 10 functionality for this example, the version at this point does not really matter.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- \n
- Create a new Universal Windows App by picking New<\/i> and Project<\/i> from the File<\/i> menu. In the dialog Visual Studio shows now, find the section Visual Basic<\/i> and Universal Windows<\/i>. From the templates, pick Blank App (Universal Windows)<\/i>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n