Unformatted Attachment Preview
Running Head: SOFTWARE TESTING
With the fast progression of AI technology and techniques of data-driven machine
learning, establishing high-quality Artificial Intelligence-based software in diverse application
domains has turned out to be an incredibly hot topic for research in both industry and academic s
communities. In the present-day world, numerous artificial technologies and machine-learning
models have been set up to construct smart application systems dependent on the inputs of
multimedia to accomplish intelligent functional features like object detection, recommendation,
prediction and classification, natural language translation and process, etc. this brings robust
demand in the quality assurance and validation of AI technologies, particularly for bug testing.
This paper aims at discussing testing (software testing) in companies. It also discusses the testing
methodologies, i.e. methodologies like regression testing, agile testing, debugging method, and
manual testing. Besides, the advantages and disadvantages of Artificial intelligence in testing are
highlighted and discussed.
In our contemporary world, with technologies making considerable strides in each sphere
of life, development of software must be accurate, quicker and convey with optimal quality.
However, bugs are the only deal breakers in the world of software. Generally, a bug is a term,
which is most unwelcomed in the process of software development (Ammann & Offutt, 2016).
This is on account that bugs indicate faults, errors, or even failures in a system or software being
set up that generated unforeseen outcomes. When bugs are identified, they should be tracked and
immediately fixed to guarantee optimal quality in a system or software that is being developed.
Bugs, in general, are predominant and fixing them consumes a lot of time, and thus
troubleshooting, Artificial Intelligence innovative technology, along with testing methodologies,
are a significant software engineering part.
Artificial Intelligence also abbreviated as AI has changed testing for the better, and is
continually enhancing the procedures identified with software testing and development. A
consumer is known to be king, and throughout the development of a company’s software, testers
ensure that the satisfaction of a consumer is guaranteed. This is the reason why using AI bots and
multiple testing methodologies in testing is inescapable.
Testing helps companies eradicate defects and bugs in the early stages with the help of AI
bots and various testing methodologies. Therefore, every company should be aware of the testing
methods and how it should be performed to allocate the right resources and their time for any
given project (Ammann & Offutt, 2016). The continuous innovation could bring a considerable
change overall in the day to day activities which will ultimately benefit any company.
Testing is characterized as a defect identifying process, where defects are any variation
between the expected and the actual results. Mistakes in coding are known as errors, and the
errors, which are identified by the testers, are known as Defects. Besides, defects acknowledged
by the development team of a company are referred to as bugs. Generally, testing processes
identify any form of errors, bugs, or defects. Therefore, it is ideal to use software testing
methodologies in the early phases of the development cycle. All prosperous companies for
software development conform to this.
Throughout the lifecycle of software development, testing is significant. As mentioned
above, testing assists companies with the detection of software bugs or faults that could impact a
software application or company in future. In the majority of the cases, testers use software
testing to help them know that there's need to change or improve anything before the company's
software is ready for use (Ammann & Offutt, 2016).
Bugs Issues and Testing
Testing in any project is very crucial so that everything runs smoothly as predicted by the
teams who are working together. If one sees any issues in their project design, requirement or
coding, it will ultimately lead to a failure which can also be called a bug. There should be
solutions prepared beforehand by the team to avoid any unforeseen issues. Moreover, it is all
about finding the bug as well as documenting it. If there is a well-documented bug report, it
gives precise information about the development issue and gives the developers the idea to start
working on fixing the bug.
According to Forbes (2019) article, it talks about how Google has been paying people to
break its stuff since 2010. The company has paid out more than $5 million in the last nine years
to find the security holes in Google code (Winder, 2019). This shows how the company are
taking bugs seriously, and it is vital to track them early. If the company fails to find about bugs,
it will ultimately lead any kind of project to fail or even unanticipated results. Furthermore, many
companies who use multiple tools to track defects of various types result in not integrating, and
by this, the team may end up with the same defect in multiple places. Some of the major areas of
concerns if a bug is critical are crashing of the system, data loss or even file corruption.
For example, HP AML tool can help correct errors in the early stages of the project.
According to an article on ALM tool integration, Application Lifecycle Management (ALM)
main aim is to increase the consistency, predictability, measurability, coordinating and managing
(Markov & Druzhinina, 2011). This can help reduce many errors as possible for the entire
Regression Testing refers to a software testing type, which evaluated if the changes to the
application or other interrelated software constituents, introduce bugs or defects. QA (Quality
Assurance) engineers perform such practices to check whether the modifications in a code hinder
or break how an application runs or how the application consumes the resources. The addition or
change in an application could prompt side effects known as regressions, and may even pop-up
in systems or components that are distinct from altered codes on account if dependencies.
Regression testing mainly focuses on identifying bugs, which have been introduced
accidentally and on guaranteeing that the past eradicated defects cannot be created. This way,
regression testing makes sure that changes in code do not influence the prevailing features of a
program. This testing methodology has to be performed each moment that a developer wants to
modify a software feature or component.
Moreover, regression testing augments possibilities to identify bugs after introduced
changes. It enables the study of unwanted side-effects that was as a result of the implementation
of the new operating surrounding. Besides, the test handles bugs such that it finds in-grained and
early-stage errors along with ensuring that the old bugs will not harm the software or the system.
Consequently, testing enhances the quality of a product. The test is needed when new features of
the software are introduced. Besides, it's mandatory to carry out this testing process when a
developer is fixing bugs or modifying the product code.
Regression test is similar to the verification method. Generally, test cases are automated
since test cases are needed to enact repeatedly and to operate similar test cases manually is
tedious and time-consuming. For instance: consider the product X, wherein one of the
functionalities is triggering acceptance, confirmation and dispatching of emails when Accept,
Dispatch, and Confirm buttons are clicked.
Regression testing does not rely on any languages of programming, i.e. C++, Java, C#,
and so forth. It's the testing methodology that is utilized in testing a product for modifications or
for performing any other updates. It validates that any changes in the product don't impact the
prevailing product modules. Authentication that bugs are fixed and that the newly added
components haven't established any issue in the past working software version.
As the multifaceted nature of the process of software development is continually
increasing, testing methodologies must evolve to keep abreast with the approaches for
development (Jan et al., 2016). Agile testing, in general, is an approach of the new generation
that centres around testing smarter instead of placing numerous efforts, but it conveys products
of high-quality. Developers and testers must have higher collaboration level in Agile testing.
Testers have to offer corrective feedback to the team that deals with the company's software
development throughout the cycle of development. This is the era of constant integration amid
development and testing approaches.
Debugging refers to the process of removing and detecting potential and existing errors
(also known as bugs) in software codes, which could cause it to crash or run unexpectedly. To
mitigate incorrect system/software operation, the debugging process is utilized in finding and
resolving defects or bugs (Peng et al., 2014). When several modules or subsystems are forcefully
couples, the process of debugging turns out to be more troublesome as any modification in one
module might prompt more bugs to appear in the other. At times, it takes a lot of time to debug
the process when compared to coding it.
Debugging varies in intricacy from fixing of simple bugs to carrying out tiresome tasks
and lengthy of scheduling updates, data analysis, and collection (Jan et al., 2016). The skill of
debugging of a programmer could be a significant factor in the capacity to debug the issue. Yet,
the trouble of debugging a software differs hugely with the system's complexity, and additionally
relies, to some degree, on the language of programming used, and the accessible tools like the
debuggers (Peng et al., 2014). Typically, debuggers are defined as software tools that help
programmers monitor the program’s execution.
High-level programming languages, in general, like Java, do make the debugging process
much more manageable, on account that they have components like type checking and exception
handling, which make the actual erratic behaviour sources easier to detect. In languages for
programming like C#, bugs might bring about silent issues like corruption of the memory and is
often troublesome to perceive where the original problem occurred. In such cases, tools for
memory debugger might be required.
Manual testing is a Software Testing type whereby the testers and developers manually
implement test cases by not using any tools for automation. It is the most primordial of all the
testing methodologies and assists with finding bugs in a software system (Rathi & Mehra, 2015).
Any of the new application should be tested manually before testing could be automated. It also
needs increased effort; however, it's mandatory to check for automation.
Manual testing methodology is one of the most fundamental processes of testing as it
could find the hidden along with the visible software defects (Rathi & Mehra, 2015). The
discrepancy amid the anticipated output and the output that is provided by the software is
characterized as defects or bugs. The developers fix the defects and hand to the testers for
Manual testing is necessary for each new software that has been developed before
automated testing. This testing method needs considerable time and efforts, yet it provides the
indemnity of the bug-free software. Besides, manual testing needs insights for manual testing
methodologies; however, not od any tool for automated testing. Manual testing is indispensable
on account that one of the basic of software testing has one per cent accurate isn't probable.
There're multiple methodologies utilized for manual testing. Some of these methods include:
Black Box Testing
Black-box testing refers to the software testing method, which inspects an application’s non-
functionality and functionality without having to plumb into the internal structure. Each Blackbox testing level, irrespective of if its’s dependent on acceptance, units or integrity, has
distinctive high-level tools for testing (Rathi & Mehra, 2015). The aim of the test isn’t to
acknowledge the application’s programming language, internal structure or code at any point in
general. Although the tester is licensed to be cognizant with the software’s outcome, isn’t
provided with the access to tell how it works, with-holding the discretion of the concerned
application. For example, if we input A, the result might be input B; however, what brings about
the impact is not known.
Principally, Black-box testing is empowered by what is called Playback and Record
Tools. Such tools are used for regression testing that checks if any moderately newer bugs have
appeared in the past working application to bring about its functionality. Such tools primarily
generate test-cases for Playback and Record in script forms like Java, TSL, Perl, and so forth
(Rathi & Mehra, 2015). In this testing method, the tester or user doesn’t have any applied
knowledge of the internal software structure. It validates the software’s functionality. Black-box
testing is especially profitable on account that black-box testers find bugs that can't be monitored
throughout the execution of a program. Testing methodologies utilized in black-box testing are
the analysis of boundary value, model-based testing, equivalence partitioning, all fuzz testing
and pairs testing, among others.
White-box testing is a testing method for the software solution's design, coding, and
internal structure. In this testing type, a code is discernible to a tester. It centres around mainly on
authentication the outputs and inputs flow via the application, enhancing usability and design,
strengthening security (Rathi & Mehra, 2015). White-box testing is dependent on the
application’s inner workings and focuses on internal testing. The tester or the user, in this case,
has expert algorithm knowledge and the test software structure. Testing methodologies utilized
are methods for mutation testing.
Artificial Intelligence in Software Testing
Artificial Intelligence (AI) is one of the state-of-art technologies that's trying to simulate
the reasoning of humankind in Artificial Intelligence Systems. John McCarthy invented the term
Artificial Intelligence in 1950 (Friedrich et al., 2016). He stated that each learning aspect or any
intelligence feature could theoretically be labelled explicitly that a machine could simulate it.
The attempt would be made in finding the way the machines can form concepts and abstractions,
solve types of issues presently reserves for people and enhance themselves. Generally, AI is the
capacity of computer programs to think and learn. Everything could be regarded as AI if it
encompasses programs that perform roles which we would typically think will depend on human
Testing tools for AI could cooperate with software testers and developers in
accomplishing enhanced software testing quality. Present-day applications interact with one
another via APIs myriad that consistently develops in intricacy exponentially while technology
evolves. The life cycle of software development is turning out to be more complicated as days go
by and therefore, the management of the time of delivery is as yet substantial. Thus, the testers
must not work harder but smarter in this new software development age (Friedrich et al., 2016).
AI testing-tools have assisted with making software updates and releases, which occur every
month to happen on a daily or weekly basis. The testing platform for AI could carry out tests
more effectively when compared to human beings, and with continuous updates to its algorithm.
However, as much as AI possesses positive accomplishment in Software testing companies, it
still does have its subsequent cons.
AI technology can drastically change the way processes operate in an organization. There
will be pros and cons, but it is up to the company to identify its benefits. According to an article,
Robot Revolution talks about robots and how they can take over, think and learn like a human
(Culligan, 2019). There is insecurity around the AI technology topic. Still, we as a human should
be able to analyze and allocate the right number of tasks that the technology can take over. There
should be proper testing conducted to identify the pros and cons of AI technology. Besides, by
the help of AI technology, there can be more AI automated tools to run to avoid as many defects
Since the efficiency and effectiveness of a testing process are vital to the company's
product, its' not surprising that numerous companies often search for faster, smarter, and better
testing ways. As AI popularity grows, an ever-increasing number of testers are acknowledging
that its ability to make time-consuming and cumbersome tasks much more straightforward.
a) Unfailing accuracy
Even the most professional testers at-times make errors, particularly when handling
recurrent tasks. This is the primary reason why automation turned out very prominent. Unlike
human beings (Reddy, 2017). Artificial Intelligence often carries out the required tasks as
calculated, finishing similar tasks effectively, repeatedly. While Artificial Intelligence function
on repetitive tasks, the testers are capable of focusing on formulating efficient solutions for
automation and on the exploratory practices, which only humans could perform.
b) Enhanced flexibility
According to Reddy (2017), even the most essential modification in the application could
prompt test failures in the automation tools on account that typical scenarios for testing take into
account the singular path or selector. Thus, such testing methodologies are at some point, rigid.
Artificial Intelligence and Machine learning permit for increased flexible testing procedures,
learning relations amid several documentation segments (Dwarakanath et al., 2018). These
systems could automatically embrace any modifications in real-time, being reliable and flexible.
c) Increased overall for test coverage
Artificial intelligence permits one to expand the tests’ depth and scope substantially. It
could check the contents of a file, states of internal program, and data tables, being capable of
quickly determining if the program functions as calculated (Reddy, 2017). Artificial intelligencepowered test-automation permit for the enactment of more than one thousand test scenarios in a
single test run that is not possible via manual testing.
d) Visual validation
Image recognition and pattern recognition empower AI in detecting visual bugs by
conducting visual testing on applications and guaranteeing that all visual components function
and appear suitably. Artificial Intelligence could acknowledge UI controls despite their shape
and size, assessing them on the level of the pixel (Friedrich et al., 2016). Even if Artificial
Intelligence can't conduct software testing with assistance from people, it can enhance the
process of testing momentously (Dwarakanath et al., 2018). The primary AI advantage is that it
takes automation to a whole new level. Therefore, the testers are not required to handle recurrent
tasks at any costs. Yet, it additionally enhances the accuracy and flexibility of the software tests,
and through machine learning and pattern recognition, permits ...