FUNCTIONAL TESTING & NON FUNCTIONAL TESTING.
Published: 2023-10-18 21:52:06

FUNCTIONAL TESTING:
   *Functional testing is a type of Software testing that assesses the functionality of an application to ensure that it performs its intended task according to specified requirements.This type of testing is concerned with what the software should do and whether it accomplishes its functional objectives accurately.There are different levels of functional Testing.
1.Unit Testing
2.Integration Testing
3.System Testing
4.User Acceptance Testing

1.Unit Testing:
        Unit testing is a type of software testing that focuses on verifying the correctness of individual units or components of a software application in isolation. A unit typically refers to the smallest testable part of an application, such as a modules. Unit tests are automated and help ensure that each component works as intended. Here are some examples of unit testing with applications:
1.Mathematical Functions:
     *Application : A scientific calculator application
     *Unit: The addition function
     *Test: Verify that when you add two numbers, the result is correct. For example, testing add(2, 3) returns 5.

2.Data Validation:
     *Application : A user registration module
     *Unit: A function that checks if an email address is valid
     *Test: Verify that the email validation function correctly identifies valid and invalid email addresses.

3.File I/O:
     *Application : A file management application
     *Unit: A function for reading and writing files
     *Test: Verify that the file I/O functions correctly read and write data to and from files.

4.Authentication:
     *Application : A user login module
     *Unit: A function that verifies user credentials
     *Test: Ensure that the authentication function correctly checks if a user's credentials are valid.

5.Date and Time Functions:
     *Application Example: A calendar application
     *Unit: A function that calculates the difference between two dates
     *Test: Verify that the date calculation function correctly computes the time span between two dates.

2.Integration Testing:
           Integration testing is a type of software testing that focuses on verifying the interactions and connections between different components or modules of an application. The primary goal of integration testing is to ensure that the various parts of an application work together as expected when integrated.
Here are some examples of integration testing with applications

1.Login and Authentication:
         *Application : A web application
         *Integration : Test how user authentication integrates with user profile access. Ensure that after login, users can access their profiles and data correctly.

2.Payment Processing System:
         *Application : An e-commerce website
         *Integration : Test the interaction between the shopping cart module and the payment gateway. Verify that when a customer proceeds to payment, the correct payment methods are offered, and the payment is processed successfully.

3.Social Media Sharing Feature:
         *Application : A content sharing platform (e.g., Facebook)
         *Integration : Test how the sharing feature integrates with various social media platforms like Facebook, Twitter, and LinkedIn. Ensure that shared content appears correctly on each platform.

4.Messaging App:
         *Application : A chat and messaging application (e.g., WhatsApp)
         *Integration : Test how messages are transmitted between users in real-time. Verify that messages are sent and received accurately and appear in the correct order.

5.Data Sync in Mobile Apps:
         *Application : A mobile app with offline functionality (e.g., Evernote)
         *Integration : Test how data synchronization between the mobile device and the cloud server works. Confirm that data changes are correctly reflected on all devices.

3.System Testing: 
           System testing is a type of software testing that evaluates the entire software system as a whole, ensuring that all components and modules function together seamlessly to meet the specified requirements. This type of testing focuses on assessing the system's overall behavior and performance.
Here are some examples of system testing with application scenarios:

1.E-commerce Website:
           *Application : An online retail platform
           *Scenario: Test the entire e-commerce system, including user registration, product browsing, shopping cart functionality, payment processing, order placement, and shipping. Ensure that all components work together to provide a smooth shopping experience.

2.Flight Reservation System:
           *Application : An airline's reservation system
           *Scenario: Evaluate the end-to-end booking process, from searching for flights to selecting seats, making payments, and receiving booking confirmations. Confirm that the system accurately reserves seats and issues e-tickets.

3.Hospital Management System:
            *Application : A healthcare information system
            *Scenario: Test the complete system, including patient registration, appointment scheduling, electronic health records, billing, and prescription management. Ensure data flows seamlessly across different departments.

4.Library Management Software:
            *Application : Library catalog and circulation system
            *Scenario: Test the entire system, covering book cataloging, check-out, check-in, late fee calculations, and reservation of books. Confirm that users can efficiently manage library resources.

5.Automated Teller Machine (ATM):
            *Application : A bank's ATM system
            *Scenario: Test the ATM's functions, including card authentication, balance inquiries, cash withdrawals, fund transfers, and receipt printing. Ensure the ATM operates securely and as expected.

4.User Acceptance Testing:
             User Acceptance Testing (UAT) is a critical phase of software testing in which end users or stakeholders validate the software to ensure that it meets their requirements and performs as expected. UAT is the final step before the software is deployed or released to production. 
Here are some examples of UAT scenarios with application examples:

1.Banking Application UAT:
              *Application : An online banking platform
              *Scenario: Bank customers perform UAT to verify that they can log in securely, check account balances, transfer funds, pay bills, and set up recurring transactions. Users confirm that the banking application is user-friendly and secure.

2.Inventory Management System UAT:
              *Application : A warehouse inventory management software
              *Scenario: Warehouse staff and managers validate the software's ability to accurately record and track inventory levels, generate reports, manage stock, and handle order processing. Users ensure the system supports their daily tasks efficiently.

3.Banking Application UAT:
               *Application : An online banking platform
               *Scenario: Bank customers perform UAT to verify that they can log in securely, check account balances, transfer funds, pay bills, and set up recurring transactions. Users confirm that the banking application is user-friendly and secure.

4.Flight Booking System UAT:
               *Application : An airline's booking platform
               *Scenario: Travelers test the system for searching and booking flights, seat selection, online check-in, and receiving e-tickets. Users confirm that the booking system meets their travel needs.

5.Library Management Software UAT:
               *Application : Library catalog and circulation system
               *Scenario: Librarians and library staff validate the software for functions such as cataloging, check-out, check-in, fine calculations, and inventory management. Users ensure the software assists them in library operations.


Here are some other Examples of Functional Testing with Applications:
1.Login and Authentication Testing:
    *Application: A Web Based E-mail Client(Eg.GMAIL)
    *Scenario: Verify that users can successfully login with valid credentials and are denied access with invalid ones.Ensure that forgotten password recovery processes work as intended.

2.Search Functionality Testing:
    *Application: An E-Commerce Website(Eg.Amazon)
    *Scenario: Check that the search features returns relevant results for various search queries.Confirm that filters and sorting options works as expected.

3.Shopping cart and Checkout Testing:
    *Application: An Online Retail store(Eg.Ebay)
    *Scenario: Verify that users can add items to their shopping cart,modify the cart,and successfully complete the purchase.Ensure tax and shipping calculations are accurate.

4.User Registration Testing:
    *Application: A Social Networking Platform(Eg.Facebook)
    *Scenario: Test the registration process,including input validation,confirmation emails,and user profile creation.Confirm that user can login after the registration.

5.Forms and Data Entry Testing:
    *Application: An Online Survey Tool(Eg.Survey Monkey)
    *Scenario: Validate the users can submit forms with different data types including texts,numbers,dates and file uploads.Check for validation messages and data storage.



Non-Functional Testing:
                 Non-functional testing assesses the non-functional aspects of a software application, such as performance, security, usability, scalability, and reliability. It is concerned with the how well the software performs in various dimensions.
Here are Some examples of Non-Functional Testing:

1.Performance Testing: 
            This includes various types like load testing (measuring system performance under expected load), stress testing (evaluating performance beyond normal load), and scalability testing (assessing the system's ability to scale with increased load). For example, testing how a web application handles a sudden spike in traffic during a flash sale.

2.Security Testing: 
            It focuses on identifying vulnerabilities in the software, such as penetration testing (attempting to exploit security weaknesses) and security scanning (automated checks for known security issues). For example, checking for SQL injection vulnerabilities in a database.

3.Usability Testing: 
            This assesses the user-friendliness and overall user experience of the software. It involves real users interacting with the application and providing feedback. For example, evaluating how easily users can navigate and perform tasks on a website or mobile app.

4.Reliability Testing: 
            It measures the software's ability to function consistently without failures. Techniques like fault tolerance testing (testing the system's ability to handle faults) and failover testing (testing the system's ability to switch to a backup in case of failure) fall under this category. 
For example, assessing a banking application's ability to recover from a server outage without data loss.

5.Compatibility Testing: 
            This tests the software's compatibility with different environments, devices, and browsers. For example, testing a website's performance and appearance on various web browsers (Chrome, Firefox, Safari, etc.).

In summary, functional testing ensures that the software performs its intended functions correctly, while non-functional testing focuses on how well the software performs in various non-functional aspects, such as speed, security, and user experience. Both types of testing are essential to ensure a comprehensive assessment of a software application's quality and suitability for its intended purpose.