Agile for Embedded Training Course (updated Feb 21 see news)
One of the core Agile Practices is Test-Driven Development (TDD). For most software engineers TDD challenges the traditional approach to software development and testing (test-after-construction). TDD changes this model by using a Test-First approach.
However, almost all current books and training on TDD ignore the challenges of applying it in an embedded systems environment. Aspects such as testing on the target, hardware dependency and managing both host and cross-compiler toolchains are generally ignored or over-simplified. In addition almost all are based on an object-oriented language, such as Java or C++ rather than C.
The course covers testing embedded C software across host, emulated and target environments.
Attendees perform practical TDD exercises based on real-world embedded requirements.
The course utilises the C based test framework Unity and CMock for test doubles.
- To understand the principles of Test-Driven Development
- How to select a suitable test framework for C development
- To identify the required toolset to support TDD beyond the test framework
- The boundary between host-based testing and target-based testing
- The challenges and pitfalls of applying TDD to an embedded system
Delegates will learn:
- How to practice Test-Driven Development
- The use of C based test harnesses for embedded systems
- API and Integration testing using test doubles (CMock)
- The importance of architectural design to practical TDD
- What TDD doesn't address
- Attendees should have a good working knowledge of the C language.
- Understand the build process (preprocessor-compiler-linker-executable)
Who should attend:
The course is designed for software engineers working on an embedded C project.
The target audience is engineers working in, or looking to move to, an Agile project environment (e.g. Scrum) and who want practical experience of using TDD for a real embedded system.
- Delegate manual
- Delegate workbook
- Delegate bootable Linux data-key with all tools installed
Approximately 50% of the course is given over to practical work.
The exercises use challenging real-world embedded problems with real-life code. Exercises cover code structuring and testing legacy code.
Agile Techniques and TDD
- Where does TDD fit in?
- Agile onion
- Embedded TDD Strategy
- Unit tests
- Red-Green-Refactor (RGR)
- 3 rules of TDD
- Failing tests
- Tests are FIRST
- File organisation
- Failure based tests
- Abstraction and encapsulation
- What can we learn from OO's SOLID Principles
Advanced Test Construction
- Breaking encapsulation (Inspecting privates)
- Running a subset of tests
- Testing vs. Test Driving
- Simple test doubles
- Dependency Challenges
- UML Sequence Diagrams
- UML State Machines
Advanced Test Doubles
- Getting Mocks in place
- Design and change
- Walking skeleton
- Importance of architecture
- Version control and branching (git-workflow)
- Building for the target
- Testing using emulation (QEMU)
- Testing on the target
Acceptance Testing and CI
- Containers and Docker
- Continuous Integration (CI) (Jenkins / Bamboo)
- Cloud-based CI builds (Gitlabs, Github Actions)
- Legacy Code Change Policy
- Refactoring legacy code
- Interfaces in C
TDD and Threading
- GPOS threading vs. RTOS tasking
- Separate threading logic from application logic
- Active Object Pattern
- Introduction to Ceedling
- Introduction to Unity
- Introduction to CMock