LabVIEW Unit Testing Course

How do you know your code really works? If testing requires running your entire system, tests are fragile or painful to maintain, and bugs keep slipping into production, you’re not alone. Many teams want better testing but struggle with inherited code, limited time, flaky tests, and slow manual processes that don’t scale. Even when integration tests exist, they often make failures harder to diagnose instead of easier.

This course shows you how to use testing as a practical, everyday development tool instead of a burden. You’ll learn how to design new code so it’s easy to test and how to add meaningful tests to existing code, even when it wasn’t written with testing in mind. The focus is on writing tests that are maintainable, reliable, and valuable, so they build confidence instead of creating more work.

You’ll learn how to balance unit and integration tests, choose the right type of test for the problem, and work effectively with hard-to-test dependencies like hardware and external systems. The course covers more than 10 types of tests, automation strategies, reporting, and testing tools. You’ll also learn how to simulate hardware, inject errors, and use tests to troubleshoot problems quickly. Object-oriented design techniques are used throughout to improve testability and clarity.

By the end of this course, you will:

  • Have fewer bugs reaching production

  • Recover from bugs faster when they do occur

  • Reduce recurring defects

  • Gain confidence that your code works

  • Be able to prove correctness to third parties

This course turns testing from a frustration into a competitive advantage.

Purchase Course

FAQs

What is this course?

1

This course teaches how to design testable code, write reliable automated tests, handle hard-to-test systems, and reduce recurring bugs so you gain confidence, faster feedback, and provable results.

Who is it for?

2

Engineers curious about incorporating Unit Testing into their workflows.

What will you learn?

3

Writing Simple Tests, Parameterized Tests, API Testing, Writing Tests for Bugs, Approval Testing, Combination Tests, Pure Functions, Spies and Doubles, Mocking, Dealing with Frameworks, Automating Tests, and GUI Testing

Prerequisites?

4

None

Syllabus

    1. Welcome from Sam

    2. What do you know?

    1. Environment Setup

    2. Hello World Demo Follow Along

    3. Hello World Review

    4. Easy Refactoring

    5. Exercise: What if we have an empty string?

    6. Defining Test Cases

    7. Zombies!

    1. Writing Simple Tests

    2. Exercise: Create Tests

    3. Tolerance

    4. Exercise: Refactoring Practice

    1. Characteristics of Good Tests

    2. Poor Parameterization

    3. Demo: Parameters Example

    4. Exercise: Parameterized Tests

    5. Thoughts?

    1. Avoid Overspecifying

    2. Stack Example with Categorization

    3. Given When Then

    4. Exercise: Testing a Stack

    5. Rule of Thumb

    1. Intro to Session 2

    2. Exercise: Yatzy Bug

    3. Thoughts on Yatzy Bug

    1. Intro + Recommended Viewing

    2. Environment Setup

    3. Follow Along: Hello World Approval Testing

    4. Review

    1. Complicated Output

    2. Complicated Output Verify Person Demo

    3. Rule of Thumb

    4. Approval Scrubbers Demo

    5. Supermarket Kata

    6. Initial Impressions

    7. Test Utility Methods Demo

    8. Supermarket Approvals Demo

    9. Supermarket Approval Printer Demo

    10. Printer

    11. Setup Teardown

    12. All Together

    13. Supermarket Review

    14. Exercise: Supermarket

    1. Built in Tools

    2. Gilded Rose Combination Approvals Demo

    3. Refactoring Practice

    1. Introduction

    2. What makes code hard to test?

    3. What is it?

    4. Safe Refactorings

    5. Exercise: Simple Serial

    1. Spies and Doubles intro

    2. Backdoor Access

    3. Com0Com

    4. Com0Com Demo

    5. Backdoor Pros and Cons

    6. Alternatives

    7. HALS

    8. Examples

    9. Serial Spy Demo

    10. Exercise: Return to Simple Serial

    1. LMock with Simple Serial

    2. LMock Serial

    3. LMock Demo

    4. Use LMock on Simple Serial

    5. SAS Mocks

    1. Timing Test Doubles

    2. Demo: Timing Test Doubles

    3. Timing Exercise

    1. Sam's Rules for Frameworks

    2. Presentations to Watch

    3. AF Unit Test

    4. Allen's Ideas Applied to DQMH

    5. DQMH Unit Testing Demo

    6. Frameworks Rule of Thumb

    1. LUnit API and Reports

    2. Prebuilds

    3. LUnit G-CLI

    4. Exercise LUnit G-CLI

    5. Switcheroo

    6. Approvals Demo

    1. GUI Testing

    2. SLL Drona

    1. Reflections and Resources

Your Instructor

Purchase Course

Sam Taggart

I am passionate about helping LabVIEW developers grow so they can confidently take on bigger and better challenges. I have been doing LabVIEW for over a dozen years. Over that time I have learned a ton. I learned a lot of it the hard way. I wish I would have had some more guidance along the way. That is why I created these courses to point junior developers in the right direction and help them to avoid stubbing their toes so much.

Questions?

Questions about the content in this course? Would you like more information on the next offering of this workshop? Interested in custom classes? Drop us a line.