ASSIGNMENT 2 FRONT SHEET

Qualification Pearson BTEC Level 5 Higher National Diploma in Computing

Unit number and title Unit 20: Applied Programming and Design Principles

Submission date Date Received 1st submission

Re-submission Date Date Received 2nd submission

Student names & codes Final scores Signatures

1. Kieu Huy Hoang – BH00429 Hoang

2. Nguyen Ngoc Thang – BH00399 Thang

Group number:
3. Hoang Phuc Lam – BH00445 Lam

4. Vu Hoai Nam – BH00435 Nam

5. Nguyen Thi Minh Nguyet – BH00468 M.Nguyet

Class SE06201 Assessor name Dinh Van Dong

Student declaration
I certify that the assignment submission is entirely my own work and I fully understand the consequences of plagiarism. I understand that making a false declaration is a form of
malpractice.
Grading grid

P5 M3 P6 P7 M4 D2
 OBSERVATION RECORD

Student 1

Description of activity undertaken

Assessment & grading criteria

How the activity meets the requirements of the criteria

Student
Date:
signature:

Assessor
Date:
signature:

Assessor
name:
Student 2

Description of activity undertaken

Assessment & grading criteria

How the activity meets the requirements of the criteria

Student
Date:
signature:

Assessor
Date:
signature:

Assessor
name:
Student 3

Description of activity undertaken

Assessment & grading criteria

How the activity meets the requirements of the criteria

Student
Date:
signature:

Assessor
Date:
signature:

Assessor
name:
Student 4

Description of activity undertaken

Assessment & grading criteria

How the activity meets the requirements of the criteria

Student
Date:
signature:

Assessor
Date:
signature:

Assessor
name:
r Summative Feedback:  Resubmission Feedback:

Grade: Assessor Signature: Date:

Internal Verifier’s Comments:

Signature & Date:

I. Introducstion
In the fast-evolving landscape of software development, ensuring the quality and reliability of
applications is paramount. Automation testing has emerged as a critical component in modern
development practices, offering significant advantages over traditional manual testing methods. This
paper explores the application of automation testing within the context of the SIMS (Student Information
Management System) project.

The SIMS project, designed to streamline and enhance the management of student information,
demands a robust and reliable system capable of handling a vast amount of data and numerous user
interactions. Given the complexity and scale of this project, manual testing alone proves insufficient to
meet the rigorous quality standards and tight development timelines.

Automation testing presents a solution by enabling repetitive and comprehensive testing processes to be
executed efficiently and accurately. By leveraging automated test scripts and tools, the SIMS project can
achieve higher test coverage, faster execution times, and more reliable detection of defects. This not
only improves the overall quality of the system but also accelerates the development lifecycle, allowing
for more frequent and reliable releases.

In this article, we will delve into the specifics of how automation testing is integrated into the SIMS
project. We will discuss the tools and frameworks employed, the benefits realized, and the challenges
encountered. Through this exploration, we aim to provide a comprehensive understanding of the pivotal
role that automation testing plays in the success of the SIMS project and, by extension, in the broader
field of software development.
I. Automation Testing apply in SIMS project

1.1. What is automation testing

Automation Testing is a software testing technique that uses automated tools and scripts to perform tests on
software applications. The purpose of automation testing is to increase the efficiency, accuracy, and
coverage of testing by minimizing human intervention. Popular tools such as Selenium for web applications,
JUnit/TestNG for Java applications, and Cucumber for natural language test scripting make automation
testing more effective.

Automation testing includes different types of testing such as unit testing, integration testing, functional
testing, regression testing, and performance testing. The automation testing process begins with designing
test cases, developing test scripts, executing tests, analyzing results, and maintaining test scripts.

The benefits of automated testing include faster speed compared to manual testing, consistency in test case
execution, scalability, and the ability to reuse test scripts. However, implementing automated testing also
presents some challenges such as initial investment in time and resources, maintaining test scripts as the
application changes, and the complexity of automating complex test scenarios.

Automated testing is an important part of modern software development methodologies, especially in Agile
and DevOps environments, where fast and reliable testing is necessary to keep up with continuous cycles of
integration and deployment.
1.2. Some framework apply in automation testing

1.2.1. Xunit

xUnit is a family of automated unit testing frameworks, derived from the original SUnit framework for
Smalltalk. xUnit frameworks are designed to support automated unit testing and test-driven development
(TDD), and they are widely used in many different programming languages.

xUnit frameworks share many common features that help standardize and simplify the automated unit
testing process. They use annotations/attributes to define test methods, assertions to verify that code
works as expected, and fixtures to prepare and clean up the test environment. Test suites and
parameterized tests help manage and execute tests more efficiently. Mocking objects support the
simulation of complex interactions, and integration with CI/CD tools optimizes the software development
process.

The benefits of xUnit frameworks include providing a consistent structure for writing tests, supporting
automated testing critical to CI/CD, improving code quality, and helping to detect errors early, reducing
the cost of fixing them later. This ensures a more stable and reliable software product.
1.2.2. Nunit

NUnit is a popular unit testing framework for the .NET platform. It is used to write and execute automated
unit tests to ensure that source code works correctly. NUnit helps developers test small pieces of code
(units) independently and verify that each piece works as expected.

1.2.3. Web Application Testing with Selenium

Web Application Testing with Selenium refers to the process of automating the testing of web applications
using the Selenium tool suite. Selenium is an open-source framework that allows testers to write scripts in
various programming languages to automate interactions with web browsers. This helps in verifying that
web applications function as expected and maintain high quality.

Key Concepts of Selenium

Selenium WebDriver: Selenium WebDriver is a core component that provides a programming interface to
create and execute test scripts. It interacts directly with the web browser, enabling it to mimic user actions
like clicking, typing, and navigating pages.

Selenium IDE: Selenium Integrated Development Environment (IDE) is a simple tool for creating test cases
through a record-and-playback mechanism. It is an add-on for Firefox and Chrome browsers and is suitable
for quick prototyping of test cases.

Selenium Grid: Selenium Grid allows running tests in parallel across different machines and browsers. This
helps in reducing the test execution time by distributing the test load across multiple environments.

Programming Language Support: Selenium supports various programming languages such as Java, C#,
Python, Ruby, and JavaScript, allowing testers to write test scripts in the language they are most
comfortable with.

Cross-Browser and Cross-Platform Testing: Selenium enables testing across multiple browsers (Chrome,
Firefox, Safari, Internet Explorer, Edge) and platforms (Windows, macOS, Linux), ensuring that the web
application behaves consistently across different environments.
Applications of Selenium in Web Application Testing

Functional Testing: Verifies that the features of the web application work according to the requirements.
Selenium can automate the interaction with the UI to ensure all functionalities behave as expected.

Regression Testing: Ensures that new code changes do not adversely affect the existing functionality.
Selenium scripts can be reused to run regression tests quickly and efficiently.

Smoke Testing: A quick set of tests to check the basic functionality of the application. Selenium can
automate these initial checks to ensure that the build is stable enough for further testing.

End-to-End Testing: Simulates real user scenarios and verifies the application flow from start to finish.
Selenium can automate complex workflows to ensure that the application performs well under realistic
conditions.

Continuous Integration/Continuous Deployment (CI/CD): Selenium tests can be integrated into CI/CD
pipelines using tools like Jenkins, Azure DevOps, and GitHub Actions. This ensures that tests are
automatically run whenever there is a code change, maintaining code quality and reliability.

1.3. Some common types of testing

1.3.1. Unit Testing

Unit testing is a software testing method where individual units or components of a software application
are tested to ensure that each unit works as intended. It involves the creation of small, isolated tests for
units of code to verify their functionality. These tests are run regularly to catch and fix any bugs early on in
the development process before they become more difficult and expensive to resolve.

Unit testing is a key component of Agile software development methodologies, such as Scrum and Kanban,
as it allows for continuous integration and delivery of small, working increments of code. Once all units in
a program are error-free and meet their requirements, larger components can be evaluated by means of
integration testing.
1.3.2. Integration Testing

Following unit testing is integration testing - the second level of the software testing process. With
integration testing, different components or modules are combined and tested as integrated units. While
unit testing focuses on individual code units in isolation, integration testing aims to identify any bugs or
clashes that can arise when multiple components interact with each other.

Independent modules can work smoothly on their own, but once integrated, they can be incompatible and
collapse with one another. Failures may stem from inconsistent code logic, shifts in requirements,
erroneous data, or other various reasons. Integration testing prevents software from such downfalls,
making sure that the unit-tested code builds work together in harmony post-integration.

1.3.3. Functional Testing

Functional testing is a type of testing which involves testing the functional requirements of the system
under test. Each of the application’s business requirements specifications is validated in this type of testing
by passing test data and comparing the actual result with the expected result.

Functional Testing is one of the quality assurance processes in the field of software testing. This is a type
of black box testing, which means that the cases it needs to consider will be based on the specifications of
the application/software or system under test. The functions will be tested by entering input values and
then checking and evaluating the output results without having to care about the internal structures or
settings of the application. Functional testing is a process of comparing the differences between the
external specifications of the software and the actual functions that the software provides. These
specifications will mostly be based on the user's perspective of the software, not related to the
technologies used or the settings inside it. The user can be anyone, if they come into contact with the
software when it is a usable product.

1.3.4. Performance Testing

Performance testing is a type of software testing that evaluates the capabilities of a system or application
under high load conditions to determine the limits of system performance and stability. It is often used to
test the system's responsiveness when multiple users access it at the same time or when a large amount
of data is processed. Performing performance testing helps ensure that the system can function properly
under high load situations and meet the needs of users. It also helps developers and testers find
performance-related issues and come up with solutions to improve the system's performance.

Types of Performance Testing:

Load Testing: Determines how the system behaves under normal and peak load conditions.

Stress Testing: Tests the system's behavior when it is pushed beyond its normal operational limits.

Endurance Testing: Checks system stability over an extended period under a specific load.

Scalability Testing: Evaluates how the system scales with an increase in user load.

Importance of Performance Testing:

Identifying Bottlenecks: Helps in identifying performance bottlenecks such as slow response times,
memory leaks, or CPU utilization issues.

Ensuring Reliability: Ensures that the system performs reliably under different load conditions without
crashing.

Optimizing Performance: Provides insights into areas of improvement to optimize the system's
performance.

Enhancing User Experience: Improves user experience by ensuring that the application responds quickly
and efficiently.

Mitigating Risks: Reduces the risk of system failures in production by identifying performance issues early
in the development cycle.

Meeting Service Level Agreements (SLAs): Ensures that the system meets the performance criteria defined
in SLAs.
To perform performance testing effectively, you can follow these steps:

Step 1 - Plan: Determine the performance testing goals, characteristics and requirements of the system or
application. Research the appropriate types of performance testing to ensure complete and effective
testing.

Step 2 - Prepare: Prepare the testing environment, including hardware, software, data and database.
Perform the steps to configure and set up the test system.

Step 3 - Execute: Execute the test using the pre-designed test scenarios. Execute the test according to
specific steps to ensure that the test results are accurate and complete.

Step 4 - Evaluate the results: Analyze and evaluate the test results to determine how well the system or
application meets the performance requirements. Take improvement steps if necessary.

Step 5 - Reporting: Generate a report on the test results, including metrics, graphs, and test team
comments. Provide the results to developers and management for decision making and further system
development.

There are many tools that support effective performance testing, some of the most popular tools
include:

Apache JMeter: One of the most popular and free performance testing tools, allowing the creation and
execution of complex test scenarios, supporting many protocols such as HTTP, FTP, JDBC, etc.

Load: A professional performance testing tool from HP, which can simulate thousands of users at the same
time and supports many protocols such as HTTP, FTP, POP3, etc.

NeoLoad: A performance testing tool developed by Neotys, which can create complex test scenarios and
simulate thousands of users at the same time.

Gatling: An open source performance testing tool, creating complex test scenarios and supporting many
protocols such as HTTP, SMTP, etc.

BlazeMeter: A cloud-based performance testing tool, allowing the creation of complex test scenarios and
simulating thousands of users at the same time.

1.3.5. Security Testing

Security testing is defined as a form of software testing to ensure that software systems and applications
are protected from vulnerabilities, threats or any other hazards that can lead to huge losses. Security
testing of any system is to find out all the possible loopholes and weaknesses in that system that can
potentially lead to loss of information, revenue exposure or damage to the company’s reputation by the
employees or outsiders of the organization. The goal of security testing is to identify threats in the system
and measure its potential vulnerabilities, so that the system is not down or exploited unintentionally. It
also helps to detect all the possible security risks in the system and helps the developers to fix these issues
by correcting the code.

Types of Security Testing

Vulnerability Scanning: This method is performed by automated software that scans the system against
known vulnerabilities

Security Scanning: identifies the weaknesses of the network and system in general, and then provides
solutions to mitigate the risks. This scanning method can be performed by both manual scanning and
automated scanning

Penetration testing: This type of testing simulates an attack from a malicious hacker. This testing involves
analyzing a specific system to check for potential vulnerabilities to an external attack or intrusion attempt.

Risk Assessment: This testing involves analyzing the security risks observed in the organization. The risk
level is classified as Low, Medium and High. This testing method suggests controls and measures to
mitigate the risks.

Security Auditing: This is a form of internal testing of applications and operating systems to find security
flaws. Auditing can also be done through line-by-line inspection of code.

Ethical hacking: is hacking an organization's software system. Unlike malicious hackers who hack systems
for the purpose of stealing, Ethical hacking is a method of hacking systems with the purpose of exposing
security vulnerabilities in the system and having a solution.

Posture Assessment: is a method that combines Security scanning, Ethical Hacking and Risk Assessments
to provide a comprehensive overview of the current security situation of an organization or system.

Importance of Security Testing:

Risk Mitigation: Identifies security vulnerabilities early to mitigate risks associated with data breaches or
unauthorized access.

Compliance: Ensures that the system complies with security standards, regulations, and industry best
practices.

Protecting User Data: Safeguards sensitive user information such as personal data, payment details, and
login credentials.

Maintaining Trust: Builds and maintains trust with users by demonstrating a commitment to security and
privacy.

Preventing Attacks: Helps in preventing common security threats such as SQL injection, cross-site scripting
(XSS), and unauthorized access.
Business Continuity: Ensures the continuity of business operations by preventing security incidents that
could disrupt services.

Steps in Security Testing:

Planning: Define security objectives, scope, and testing methodologies.

Discovery: Identify assets, threats, and vulnerabilities in the system.

Attack Simulation: Simulate attacks to test the system's defenses and response mechanisms.

Analysis: Evaluate the results of security tests, prioritize vulnerabilities, and provide recommendations for
remediation.

Reporting: Document findings, vulnerabilities, risks, and recommendations in a comprehensive report.

Tools for Security Testing:

Burp Suite: Web application security testing tool for scanning and identifying vulnerabilities.

OWASP ZAP (Zed Attack Proxy): Open-source web application security scanner for finding vulnerabilities in
web applications.

Nessus: Vulnerability assessment tool for identifying security issues across networks, applications, and
databases.

Metasploit: Penetration testing tool for identifying and exploiting security vulnerabilities.

1.3.6. User Acceptance Testing (UAT)

User Acceptance Testing (UAT) is the final phase of the software testing process where the end-users
validate the system to ensure it meets their requirements and functions as expected before it goes live.

UAT Objectives:

Validate requirements: Ensure the system meets end-user requirements.

Quality assurance: Test the system for accuracy, functionality, and performance before deployment.

Identify risks: Identify and mitigate potential risks before the system goes into production.

Enhance user satisfaction: Ensure the system is easy to use and meets user expectations.

UAT implementation process:

Preparation: Define UAT scope, objectives, and plan, identify users involved.

Test case design: Define test cases, create test cases based on user requirements.

Test execution: Users perform testing according to the designed test cases.
Defect management: Record and track detected defects, ensure they are fixed and retested.

UAT completion: Evaluate test results, determine whether the system is ready for deployment.

Types of UAT:

Alpha UAT: Performed by internal testing team before delivering the system to end users.

Beta UAT: Performed by a select group of end users to gather feedback.

Contractual UAT: Based on the terms of the contract between the customer and the supplier.

Benefits of UAT:

Early error detection: Helps detect and fix errors before the system goes into production.

Increased user satisfaction: Ensures the system meets the needs and expectations of users.

Risk reduction: Helps minimize information security and quality risks.

Cost savings: Fixing errors detected early will help avoid large costs later.

1.4. Compare between types of testing

https://www.educba.com/automation-testing/

https://minhphien.com/wp-content/uploads/2021/02/8-XUnit.png

II. Implementation of application and testing

2.1. Implementation
2.1.1. Login
 Figure 1

HTML Structure:

Set up the HTML document with the <html>, <head>, and <body> tags. Set the document language to
English and configure the viewport so that the website displays well on mobile devices.

CSS Styles:

Use CSS to style the elements on the page, including the body, the login form container, the title, form
groups, input boxes, buttons, and error messages.

CSS makes the page look clean, user-friendly, and easy to use.

Body Content:

Container: Contains the entire content of the login form, with settings for size, background, shadow, and
rounded corners.

Title: Displays the "Login" title of the page, centered and colored blue.

Login Form: Use Html.BeginForm to create a form that sends a POST request to the Login method of the
Authentication controller.

Username and Password: Use @Html.LabelFor and @Html.TextBoxFor to create labels and input boxes
for username and password.
Error Message: Display error messages from ViewBag.error if there is an error during the login process.

Buttons: "Login" button to submit the login form, and "Back" link to return to the home page.

2.1.2. Registration
 Figure 2

2.1.3. Account management

2.1.4. Assign course to account
Figure 3
2.1.5. Authentication and authorization
 Figure 4

2.2. Apply XUnit for testing

2.2.1. Create new XUnit project
Step 1: Start Visual Studio on my computer. If I already have a project, click on that existing project.
 Figure 5

Step 2: I click on View and select Solution Explorer

Figure 6

Step 3: I am in a project, the project name will appear in the Solution Explorer bar:
 Figure 7

Step 4: Right-click on the name of the existing project and in the Solution Explorer toolbar, its tools will
appear and I point to Add and in the Add bar, its other tools will appear and I click on New Project.
 Figure 8

Step 5: After clicking on New Project, a table will appear on my computer screen as follows:
 Figure 9

Step 6: When the table appears, I point to the search bar and click on it and find xUnit Test Project

Figure 10

Step 7: After finding the uNit test bar of C#, I click Next to create a new project. And after clicking Next, a
table will appear and I name my new project and click Next.
 Figure 11

Step 8: After clicking Next, a new panel will appear and in this panel, under Framework, I select the
Framework extension and it will show 2 options which are .Net 6.0 (Long Term Support) and .Net 8.0
(Long Term Support) and you select Net 6.0 (Long Term Support) and click Create. So I have created a
new project.

Figure 12
Figure 13
2.2.2. Test login
2.2.3. Test creat account
2.2.4. Testing assign teacher and student to course

Figure 14

Figure 15

The interface has a section titled “Create New Teacher” with fields to enter the teacher’s full name,
email, and other relevant information. There is also a “Back to List” button, indicating that this is part of a
larger application or system for managing teachers and students. The specific purpose of this interface is
to allow administrators or authorized users to add new teachers to the system. This is likely a common
feature in student management software, allowing schools or educational institutions to easily recruit
new teaching staff and organize their profiles.
 Figure 16

The first image shows the “Teacher List” page, which displays a list of teachers with full names, class
information, and action buttons (Edit, Details, Delete) for each teacher.

The second image shows the “Teacher Details” page for teacher Nguyen Thanh Trieu, which displays the
teacher’s full name and class information. This page can allow users to view and edit teacher details.

The purpose of these interfaces is to provide administrators or authorized users with a centralized
viewing and management tool for teachers in the student management system (SMS). The “Teacher List”
page allows users to quickly browse and access individual teacher profiles, while the “Teacher Details”
page allows for more detailed management of information about a specific teacher.

These interfaces are essential components of SMS, allowing schools or educational institutions to
efficiently organize and maintain data about their teaching staff, which is vital for a variety of
administrative and operational tasks.
 Figure 17

The first image shows the “Courses” page, which displays a list of courses. Each course has a “Course ID,”
“Name,” and three action buttons: “Edit,” “Details,” and “Delete.”

The second image is also a “Courses” page, but shows an additional course named “CM.”

The third image is the “Edit Course” page, which allows users to edit course details. This page has fields
for “Course ID” and “Name,” as well as “Save” and “Return to List” buttons.
The general purpose of these interfaces is to provide administrative tools for managing courses in a
student management system (SMS). The “Courses” page allows users to view, edit, and delete course
information, while the “Edit Course” page allows users to update the details of a specific course.

These interfaces are vital for schools or educational institutions to efficiently organize and maintain their
courses, which is an essential component of SMS. The ability to create, update, and delete courses helps
administrators ensure the accuracy and relevance of the course catalog for students.

III. Effectiveness of using SOLID principles and clean coding

3.1. Apply SOLID in the SIMS project
3.1.1. SRP
When designing a student information management system (SIMS), applying the SOLID principles is an
important foundation to ensure the flexibility, maintainability, and extensibility of the software. Among
the SOLID principles, two principles that play a key role are the Single Responsibility Principle (SRP) and
the Open/Closed Principle (OCP).

The Single Responsibility Principle (SRP) requires that each class/module should have only one reason to
change.

 Separate functions related to student management, class management, score management, etc.
into separate classes/modules.
 Each class/module should have only one responsibility, such as the StudentManager class only
manages information and activities related to students.
 When a specific function needs to be changed, just change the corresponding class/module
without affecting other classes/modules.

3.1.2. OCP
The Open/Closed Principle (OCP) requires that software components be designed to be extensible, but
not changeable (closed). In SIMS, we can apply OCP by using the following:

 Use interfaces to define the behavior/functionality of components, instead of using concrete

classes.
 When you need to add new functionality, create a new class that implements the corresponding
interface, instead of modifying existing classes.
 Use composition-based designs instead of inheritance to avoid dependencies on concrete classes.

Applying SRP and OCP will make the SIMS project easier to maintain, extend and adapt to future changes.

3.1.3. Examples of applying SOLID principles

3.2. Effectiveness of using SOLID principles
Applying SOLID principles, especially Single Responsibility Principle (SRP) and Open/Closed Principle
(OCP), will bring many benefits to the SIMS project.

Firstly, it will create flexibility and ease of maintenance for the system. Classes/modules designed
according to SRP will have a single responsibility, easier to understand and maintain. When a specific
function needs to be changed, only the corresponding class/module needs to be edited without affecting
other parts of the system. Applying OCP allows components to easily extend the functionality without
changing the existing code.

Secondly, it will promote code reuse. Classes/modules that are isolated and have clear responsibilities
will be easily reused in other projects or upgraded versions of SIMS. Using interfaces instead of specific
classes increases code reuse, because we can implement interfaces with different classes depending on
the requirements.

Third, it will increase testability and adaptability. Small and single-responsibility classes/modules will be
easier to test and debug. When a function needs to be changed, only the corresponding class/module
needs to be focused on without affecting other parts. The use of interfaces allows for easy replacement
of specific implementations, which increases flexibility during development and testing.

Finally, it will increase extensibility and integration. By applying OCP, new components can be easily
added to the system without affecting existing components. Separating classes/modules by function also
increases the ability to integrate with external systems, as we can easily replace specific implementations
depending on the requirements.

Overall, applying SOLID principles, especially SRP and OCP, will make SIMS easier to maintain, extend,
and adapt to future changes. This will increase efficiency and reduce the cost of system development and
maintenance throughout the project life cycle.

3.3. Clean coding in the application

IV. Benefits and drawbacks of different forms of automatic testing

Figure 18: Automic Testing

Automated testing is a software testing technique as opposed to manual testing, which means it
proposes the use of special software tools to execute pre-programmed tests with minimal human
intervention. It is considered an essential activity for DevOps and Agile development.

As a rule, automated testing is implemented only after the initial manual testing and when the
application under test (AUT) is stable enough. Test scripts written in a specific programming language are
used to navigate through the AUT and compare the expected test results with the actual results recorded
in the test log. Once written, the test scripts can be re-run as often as required. To avoid testing errors as
well as to get accurate results, it is important to keep the test scripts in line with the changes in the
developed application. In addition, automating additional scripts across the entire system whenever
relevant is equally important. The problem is that it does not make sense to automate all tests, but only
those that are repetitive, data-driven, time-incentivized, of critical importance to the business, etc.

To achieve maximum efficiency and reduce maintenance costs, test automation frameworks are used. A
test framework is a set of guidelines that outline the principles of test design and scripting. In general,
test automation is the solution to implement if there is a pressing need to optimize and speed up the QA
process.

4.1. Some benefits of different forms automatic testing

Speed

Speed is perhaps the most important advantage of automated testing. With its help, the entire scope of
testing can be performed at lightning speed compared to manual testing techniques. Incredible speed is
provided not only with the ability to execute tests quickly but also with the ability to execute tests
simultaneously on multiple devices or platforms. The opportunity to run tests outside of business hours
also contributes to speeding up the QA process. Therefore, automated testing is a great way to reduce
time to market.

Fast Feedback

As long as automated tests can be run whenever needed and at a high speed, the development team as
well as the management team can benefit from fast feedback. This approach is beneficial because
developers can quickly identify the cause of errors and fix them. It is always easier to get insights from
newly written code than from code written a few weeks or months ago.

High Test Coverage

With automated testing, there is an opportunity to test test scenarios that cannot be tested manually.
First of all, it is subject to various types of performance testing. Also, as long as automated tests can run
without human supervision, the QA team has more time and can focus on designing and executing
additional tests, which in turn also results in higher test coverage and thus better product quality.

Cost-effective

As an application is being developed, the testing scope increases. To cope with this and meet deadlines,
the number of QA engineers needs to be continuously increased. As a result, the cost of testing is
constantly increasing. In this case, automated testing is what you need because a skilled automated QA
engineer can replace a team of manual testers. Automated testing is really cost-effective in the long run
whenever it comes to ambitious projects because the more often you rerun automated tests, the higher
ROI you get.

Accuracy

Since manual testing is subject to fatigue, boredom, and burnout, there is always a high risk of errors.
Automated testing does not have such dangers. Each time the automated tests are executed only in the
pre-programmed manner. Hence, there is no room for errors and omissions and the team can calculate
the test results with certainty.

Reusability

As mentioned earlier, the whole beauty of automated testing is that the test scripts once created can be
re-run whenever you need to test the software for errors that may have appeared due to any changes in
the source code or environment.

Autonomy

Automated testing aims to minimize the efforts of testers by eliminating or minimizing human
intervention. Since test scripts can run unattended and at any time of the day or night, the QA team can
focus on other important or creative tasks.

High Quality
Automated testing is not only about speed but also about efficiency. By implementing testing, you can be
sure of high product quality as all required tests can be performed within the stated time frame and with
high accuracy.

4.2. Drawbacks of different forms automatic testing

As you see the list of automation testing advantages is pretty long and in fact, it can be extended with
many more. However, at this point, we would like to draw your attention to another side of the coin. The
thing is that along with pros automation testing also has certain corns. Moreover, some of its pros can be
its corns at the same time. Let's delve into details.

Significant investment

Automation testing is rather expensive in the initial stage and requires a significant upfront investment.
Despite the open-source automation frameworks and tools are available today there is often a need for
commercial ones. It must be noted that automation tools are expensive while far too often one tool does
not support all types of testing. Investment in automation testing justifies itself only when it is
implemented in large-scale projects.

High learning curve

Automation testing requires coding skills and expertise in the most diverse tools and technologies.
Therefore to shift to automation testing you should train your available staff or hire experienced
automation QA engineers and seasoned automation QA architects. It is worth mentioning that the latter
is pretty hard to find on the job market.

Challenging test debugging

Whenever tests fail, the reason is a defect in a tested application or test scripts. An error in the test script
sometimes may result in catastrophic consequences. Still, pretty often it is not easy to locate an error in
tests and fix it. A rich experience is needed to cope with this.

Ongoing test maintenance

Since a developed application undergoes constant changes, available test scripts must be
correspondingly maintained and updated after each code modification in order not to fail during the next
test run. Test maintenance can be rather costly and time-incentive. To make the maintenance process as
hassle-free as possible, it is recommended to use the most suitable and efficient frameworks and testing
tools.

Not immediate implementation

Automation testing cannot be implemented from the very outset. Automated tests can be run only after
initial manual testing and when an application is stable enough. Besides, shifting to automation testing
requires serious preparation that can be pretty time-intensive as there is a need to find specialists if you
do not have them in place, select test automation framework and tools, or even build your own
framework from scratch, write test scripts, etc. So for small projects manual testing is more relevant in
terms of both time and money.

Narrowness

Earlier we mentioned that automation testing provides high test accuracy as they are executed according
to the preprogrammed scenario. However, this approach also has the other side. In these terms,
automated testing can be compared with a fabulous Ferrari on a well-studied and straight track, while a
human tester is a range-roving vehicle on a tricky mountain road. What we want to say is that
automation testing has certain limitations due to its specificity, as a result, unlike manual testing,
automation testing cannot execute random testing and without timely maintenance may face numerous
failures as scalability issues grow.

https://www.deviqa.com/blog/automation-testing-process-guide/

V.Conculsion
The Student Information Management System (SIMS) is a comprehensive solution designed to help
educational institutions effectively manage information and activities related to students. SIMS not only
provides the capability to track and store personal and academic data of students but also supports
registration processes, scheduling, and academic performance assessment. By applying computing
principles and theories, SIMS ensures accuracy, security, and flexibility in data management while
offering analytical tools to enhance educational quality. This system not only saves time and resources
but also improves decision-making based on data, meeting the needs of schools, students, and
stakeholders.