Smoke testing is a preliminary test performed on software to ensure major functions work before further testing. It originated from hardware testing where turning on new hardware without it catching fire was considered a pass. Smoke tests check core functionality at a high level without detail to quickly reveal failures severe enough to reject a prospective release. They help conserve time and resources by screening out builds with major defects early in the development process.

1. INTRODUCTION
Smoke Testing is a quick-and-dirty test that the major functions of a piece of software work.
Originated in the hardware testing practice of turning on a new piece of hardware for the first
time and considering it a success if it does not catch on fire. In software testing, a smoke test
is a collection of written tests that are performed on a system prior to being accepted for
further testing. This is also known as a build verification test.
Smoke test refers to the first test made after repairs or first assembly to provide some
assurance that the system under test will not catastrophically fail. Smoke testing is conducted
to ensure whether the most crucial functions of a program are working, but not bothering with
finer details. (Such as build verification).
Smoke testing originated in the hardware testing practice of turning on a new piece of
hardware for the first time and considering it a success if it does not catch fire and smoke. In
software industry, smoke testing is a shallow and wide approach whereby all areas of the
application without getting into too deep, is tested.
Smoke testing is a preliminary to further testing, intended to reveal simple failures severe
enough to reject a prospective software release. Smoke testing performed on a particular
build is also known as a build verification test. Smoke tests can either be performed manually
or using an automated tool. When automated tools are used, the tests are often initiated by the
same process that generates the build itself.
In software engineering, a smoke test generally consists of a collection of tests that can be
applied to a newly created or repaired computer program. Sometimes the tests are performed
by the automated system that builds the final software. In this sense a smoke test is the
process of validating code changes before the changes are checked into the larger production
official source code collection or the main branch of source code.
Smoke testing is non-exhaustive software testing, ascertaining that the most crucial functions
of a program work, but not bothering with finer details. Smoke testing involves running a
series of tests before entering into the full scale testing of the application that is under
development. The main objective behind smoke testing is to know whether the essential
functions of the applications are working or not. In case they are found to be not working,

2. additional modifications and changes are introduced before the application can proceed to
other tests.
Such modifications may need to continue until a time when all essential functions go through
the smoke test. Smoke test can be an invaluable tool that helps you conserve precious time,
energy and money; if any of the software feature fails smoke test, then the developers need to
think of additional modifications to the application.
Testers use smoke test from time to time especially during development phase. It will also
help you hasten and improve the software developmental process and reduce the timeframe
for development. You can also perform smoke testing at the first phase to ensure that the
particular product does not turn a failure.
TYPES OF SOMKE TESTING
Smoke tests can be broadly categorized as functional tests or unit tests:
1. Functional tests exercise the complete program with various inputs.
2. Unit tests exercise individual functions, subroutines, or object methods.
Both functional testing tools and unit testing tools tend to be third-party products that are not
part of the compiler suite. Functional tests may be a scripted series of program inputs,
possibly even with an automated mechanism for controlling mouse movements. Unit tests
may be separate functions within the code itself, or driver layer that links to the code without
altering the code being tested.
ROLE OF SMOKE TEST IN SOFTWARE DEVELOPMENT
The term 'smoke' test is metaphorical when used in software testing. Software developers
perform smoke test on new programs. Automated tests can help them build better software
applications. Smoke tests can act as validating tests for the embedded codes when there are
some modifications or changes to the application architecture. After validation, you can
integrate the changes into the final code collection. You also need to run the test again to
validate the entire code set and to find out, if there are other errors that need an immediate
fix. Smoke testing is cheaper and is result oriented.

3. Build verification test is another name for smoke testing. Both of these tests are shallow and
wide in their perspective. The tester who works on the program should look into all possible
sectors of the program without having a deep understanding of how the software application
works.
There is really no need for the tester to know how the entire process flows, he only needs to
know if the particular software does what it is supposed to do. In case, when the software
application fails, then you can safely assume that it is indeed a failure and you just cannot
proceed further on testing.
SMOKE TESTING ADVANTAGES
Software development industry also uses smoke test. It acts as a prerequisite test before
conducting any other tests. Using smoke testing at the first stage of the software development
will help you reveal the errors and possible failures on the software. A big failure or
breakdown will help the developers decide whether they need to discard the project or not. It
may also provide them invaluable clues on the types of modifications that can repair the
anomaly.
But aside from software development, smoke testing can be used in many other fields
including in the areas of electronics, plumbing, and even woodwind repair. For example,
smoke tests conducted in plumbing will measure the actual passage of smoke that passes
through the pipe. In case of any leakage, the plumber could easily see the smoke coming out
of the pipe.
In an electronic industry, smoke testing helps the engineers to find out whether a circuit
works or not. They will also be able to determine if the wiring is placed correctly or not. In
case the engineers have made a mistake then smoke will appear from the circuit. In fact, the
term smoke testing took its birth in the hardware industry.
A smoke test is a subset of the test cases that is typically representative of the overall test
plan. Smoke tests are good for verifying proper deployment or other non-invasive changes.
They are also useful for verifying a build is ready to send to test. Smoke tests are not
substitute for actual functional testing.

4. IMPLEMENTING SMOKE TESTING
Generally, quality assurance section develop and run the actual test on all new software
applications. Test cases come to use while testing the functions of software. In fact, these
tests are not simple and low-level tests, they consists of almost 30 different high-level cases
that every software applications will pass.
In addition, there are strict and stipulated needs for the application to pass through the smoke
test. Obviously, this test is the first test that a software application undergoes in its life cycle.
If there is a failure, you can assume that there are problems in the developmental process. In
reality, a team of software engineers works on the software project and each of them will
need to use the test to pass the code sets.
The quality assurance department should ensure that their project should not undergo
additional testing unless the previous failures undergo serious changes from the
developmental team. You may also wish to run the test in an automatic mode. This mode can
speed-up up the process of testing so that you can conserve precious time to market.
A given software system can fail at times. It could happen in a typical team based
development environment. Peer pressure and constant evaluation can help prevent this
possible failure. However, the team as a whole can work to solve many problems of software
development. To create an error-free software application, you may need to fix all major
functionality defects and errors in the initial stages of the project; smoke testing will come to
your help to check certain phases of software applications.
CONCLUSION
Smoke testing does provide lot of benefits to the software development team. First, it can
expel all those software applications that lack the potential to reach the market. In this way,
software engineers can easily reject those software projects that are still in their early stages
of development. If they find some errors in such projects, they can either modify it or reject
the whole project. With smoke testing, you can conserve time and money as it passes the
application for other future tests.

5. In addition, this test also allows software developers to learn different aspects of the program
that needs further improvements. They will also be cautious in the future and avoid making
similar mistakes again. Smoke testing at an earlier stage will help you avoid major
modifications and changes to the core design of the applications.
REFERENCES
• http://en.wikipedia.org/wiki/Smoke_testing
• http://www.softwaretestingmentor.com/types-of-testing/smoke-testing.php
• http://www.exforsys.com/tutorials/testing-types/smoke-testing.html
•