Component and Interface Testing

Component Testing

• Software components often consist of multiple interacting objects
• In weather stations, a reconfiguration component may utilize various objects to manage different reconfiguration aspects.
• Component interface functionality is accessed through the composite component's defined interface
• Component interface testing ensures performance aligns with specifications
• Unit tests must be completed for objects within the component before component testing
• Component testing verifies the integrated functionality of composite components against defined interface requirements

Interface Testing

• Objectives include identifying interface errors and incorrect assumptions related to how interfaces operate
• Four types of interfaces include:
  • Parameter Interfaces: Data is passed between methods or procedures
  • Shared Memory Interfaces: Memory blocks are shared among procedures or functions
  • Procedural Interfaces: Sub-systems offer procedure sets for other sub-systems to call
  • Message Passing Interfaces: Sub-systems request services from other sub-systems through messages
• Interface testing guarantees interactions are correct and components communicate as expected

Interface Errors

• Interface Misuse:
  • Occurs when a component incorrectly uses another's interface
  • An example would be passing parameters in the wrong order
  • Additionally, calling a method with incorrect arguments is an example of interface misuse
• Interface Misunderstanding:
  • Arises from incorrect assumptions about a component's behavior
  • An example is assuming a method will always return a value in a specific range, but it doesn't
• Timing Errors:
  • Occur due to disparities in components' operational speeds
  • They can result in the use of outdated information
  • An example is when a component reads stale data because another component hasn't updated it in time
• Addressing these errors ensures reliable interactions between components

Interface Testing Guidelines

• Extreme Parameter Values: Design tests with parameters at the extreme ends of their ranges to ensure robust handling
• Null Pointer Testing: Always test pointer parameters with null pointers to verify proper error handling
• Failure-Inducing Tests: Create test scenarios that intentionally cause the component to fail, which is done to check robustness and error recovery
• Stress Testing: Apply stress testing in message passing systems to evaluate performance under high loads or intensive use
• Order Variation: In shared memory systems, test activation order variations to ensure proper synchronization and data handling
• Adhering to these guidelines thoroughly tests interfaces for reliability and robustness in various conditions

System Testing

• During development, system testing integrates components into a complete system for testing purposes
• Testing focuses on interactions between components to ensure proper collaboration
• Objectives include verifying component compatibility, expected interactions, and correct data transfer across interfaces
• Assess the system's emergent behavior, which combines component interactions not apparent when components are tested in isolation
• System testing ensures the integrated system functions correctly and meets its requirements

System and Component Testing

• During system testing, reusable and off-the-shelf components are integrated with newly developed components and the system is tested as a whole
• System testing integrates components developed by different team members, focusing on the interactions between integrated parts
• System testing is performed by a dedicated team to ensure separation which ensures an objective evaluation of system functionality and integration
• System testing ensures all parts operate as intended and identifies integration issues

Use-Case Testing

• Use-cases, which describe user interactions with the system, are for guiding system testing
• Each use-case involves multiple components, ensuring interactions are exercised and validated
• Sequence diagrams associated with use-cases document the components and their interactions
• These diagrams help to understand and test the interaction flow described in the use-case
• Use-case testing ensures real-world performance by verifying interactions among components through practical use-case scenarios

Testing Policies

• Exhaustive Testing: Testing policies help define the required coverage and focus of system testing since not every possible scenario can be tested.
• Examples of Testing Policies:
  • Menu Functions: Every menu-based system function needs testing
  • Function Combinations: Combining functions in the same menu requires testing
  • User Input: All functions with both correct and incorrect user inputs need testing
• Testing policies guide testing by pinpointing critical areas, which helps ensure essential functionalities and use cases are checked thoroughly

Test-Driven Development (TDD)

• TDD integrates testing and code development by constructing tests before writing the actual code
• Tests are created first, with passing these tests being the primary focus of development
• Code is developed incrementally, with each increment accompanied by a corresponding test
• Development of new increments proceeds only once the existing code passes its test
• TDD originated within agile methodologies but can also be applied in traditional plan-driven development processes
• TDD emphasizes writing tests early, ensuring code is continuously validated and each new feature is tested as it's developed

TDD Process Activities

• Identify Increment: Determine a small, manageable piece of functionality to implement
• Write Test: Create an automated test for the identified functionality, defining expected behavior and outcomes
• Run Test: Execute the new test along with all existing tests, with the new test initially failing
• Implement Functionality: Develop the code required to fulfill the functionality described by the test
• Re-Run Tests: Re-run the tests to ensure the new functionality works as expected
• Move to Next Increment: Proceed to identify the next piece of functionality once all tests pass
• This process tests and validates each piece of functionality before moving on, promoting reliable development

Benefits of Test-Driven Development

• Code Coverage: Guarantees every code segment has an associated test, providing comprehensive coverage
• Regression Testing: A regression test suite grows incrementally, validating that changes do not break the existing functionality
• Simplified Debugging: Pinpoints problems in the newly written code when a test fails and simplifies the debugging process
• System Documentation: Tests serve as documentation, clearly describing the code's intended behavior

Regression Testing

• Purpose: To verify that recent changes or additions have not adversely affected existing functionality
• Manual vs. Automated:
  • Manual Testing: Costly and time-consuming
  • Automated Testing: Simple and efficient due to automated reruns
• Pre-Commit Requirement: All tests must pass before finalizing changes
• Regression testing ensures integrity of existing code to maintain functionality

Release Testing

• Purpose: Testing a specific release of a system intended for use outside the development team and ensuring necessary quality standards are met.
• Primary Goal: To assure the system is reliable and suitable for deployment, demonstrating specified performance and dependability and avoiding failure during normal use.
• Testing Approach: Typical black-box testing based only on the system specification, therefore, negating the knowledge of internal implementation details
• Release testing validates that systems meet required criteria and real-world expectations

Release Testing vs System Testing

• Release Testing:
  • Validates the final product before release, making it system testing
  • Conducted by separate teams
  • Objective: Ensures system requirements are met/performed well and ready for external use
• System Testing:
  • Finds bugs during development
  • Performed by the development team
  • Looks to discover defects and make sure the components work as intended
• Release testing aims to meet user requirements, while system testing focus on debugging the development phase

Requirements Based Testing

• A testing approach involving an examination of each system requirement and developing corresponding tests to satisfy those requirements
• For MHC-PMS:
  • Allergy Warning: Patient allergies to medication has to produce a warning
  • Ignoring Warnings: Prescribers must provide a reason for ignoring warnings
• Specific Test Cases:
  • No Allergy: No allergy-related medication should produce a warning
  • Known Allergy: Allergens should provide warnings
  • Multiple Allergies: Allergenic drugs must produce warnings
  • Multiple Warnings: Drugs must produce warnings
  • Overriding Warnings: Must prompt a reason for overriding the warning
• The above ensures specified functionalities and tests are properly implemented

Features Tested by Scenario

• Authentication: Correct user authentication processes need verification
• Data Transfer: Data handling and transfer of patient records to laptops should be proper
• Home Visit Scheduling: Functionality and usability of home visits needs scheduling
• Data Encryption/Decryption: Data security and integrity must be ensured on mobile devices
• Record Management: Record management needs to perform as expected when retrieving and modifying
• Additional Features:
  • Drug Database Integration: Drugs interaction needs accurate data
  • Call Prompting System: Prompt calls must have functional reliability
• Above ensures critical features are validated

A Usage Scenario for the MHC-PMS

• Kate, a mental health nurse, visits patients to check if treatment works and determine if they are suffering from medication side effects
• Kate logs into the MHC-PMS to print her schedule/patient data, encrypting patient records on request
• By checking on Jim, Kate checks Jim's record for medication side effects and suggests a clinic visit for medication changes
• Kate enters a prompt to call him to make an appointment and Kate encrypts Jim's record
• Kate uploads the records of those visited back to the database and a call list is generated of patients for Kate to contact for follow-up information

Performance Testing

• Performance testing is part of release testing to evaluate performance and reliability
• Tests should reflect typical usage patterns
• Approach: Conduct tests with progressively increasing load to identify when performance becomes unacceptable.
• Objective: Handle system demands and ensure performance criteria is met
• Approaches to stress testing include:
  • Approach: Deliberately overload the system
  • Objective: Determine how it fails and recovers, identifying potential weaknesses
• Performance testing ensures efficient and reliable operation under conditions and supporting real-world use

User Testing

• Getting user feedback is important to address system testing by impacting factors like performance, robustness, and reliability
• Types of User Testing:
  • Alpha Testing:
    • Uses collaboration with development for testers
    • Objective: Finding issues and refine the software with feedback from real people
  • Beta Testing:
    • Users release a version for users outside of a company to give feedback
    • Helps to discover problems and provides users to solve them
  • Acceptance Testing:
    • Customers test a system to see if it meets requirements to see if its ready
    • Objective is to see if it fills user needs and environments
• Above is important because it makes sure system's needs work in the real world

Agile Methods and Acceptance Testing

• User Involvement: The user is integrated into the development team, which makes them responsible for making decisions on if the system is acceptable
• Test Definition and Integration: User are responsible for making tests and have it run for them
• Acceptance Testing Process: Acceptance is tested within the development process
• Main Challenge: Feedback has to affect potential users and stakeholders for them to feel in control