Sei sulla pagina 1di 2

types of testing what it is example

seems like a mini whateverfall iterating on itself, supposedly some of the phases
agile can be done parallel. at the end of every iteration you should have shipable
product
an accumulation of uncompleted work or matters needing to be dealt with;
backlog ordered list of items representing everything that may be needed to deliver a
specific outcome.
Behavior-driven an extension of test-driven development: development that makes use of a
development (BDD) simple, domain-specific scripting language
examining functionality without any knowledge of internal implementation,
blackbox
without seeing the source code
error, flaw, failure or fault in a computer program or system that causes it to
bug
produce an incorrect or unexpected result, or to behave in unintended ways.
practice of merging all developer working copies to a shared mainline several
continuous integration jenkins
times a day
testing done using a table of conditions directly as test inputs and verifiable
Data-driven testing (DDT) outputs as well as the process where test environment settings and control are
not hard-coded
When a small number of modules contains most of the bugs detected or show
defect clustering
the most operational failures.
methodology used to test whether the flow of an application is performing as For example, a simplified end-to-end testing of
designed from start to finish. an email application might involve:
The purpose of carrying out end-to-end tests is to identify system dependencies
and to ensure that the right information is passed between various system Logging in
End-to-end testing components and systems. Accessing the inbox
The entire application is tested in a real-world scenario such as communicating Opening and closing the mailbox
with the database, network, hardware and other applications. Composing, forwarding or replying to email
Checking the sent items
Logging out
exploratory testing simultaneous learning, test design and test execution
bases its test cases on the specifications of the software component under test
functional testing
(describes what system does)
having knowledge of internal data structures and algorithms for purposes of
graybox
designing tests, while executing those tests at the user, or black-box level
integration verify the interfaces between components against a software design
kanban board with three columns: to do, in progress, and done
levels of testing code->unit->integration->system->acceptance
load understand the behaviour of the system under a specific expected load jmeter
non functional testing
verify whether, after introducing or updating a given software application, the
non regression
change has had the intended effect
object design pattern in Selenium, where:
page object
web pages == classes,
model/method/pattern/wha
elements == class variables,
tever
user interactions == class methods
authorized simulated attack on a computer system that looks for security
penetration test weaknesses, potentially gaining access to the system's features and
data
a testing practice performed to determine how a system performs in terms of
performance
responsiveness and stability under a particular workload
If the same tests are repeated over and over again, eventually the same test
pesticide paradox
cases will no longer find new bugs.
verifies that software which was previously developed and tested still performs
regreesion
the same way after it was changed or interfaced with other software
rest way of providing interoperability between computer systems on the Internet
basic test to quickly evaluate whether a claim or the result of a calculation can
sanity testing
possibly be true
follows a set of fixed length iterations in which the product is
developed. Each of these iterations are called as Sprint. Typically,
each sprint is fixed somewhere within 2 weeks to 1 month.
during each sprint there are daily meetings (standup/scrum). roles: product
scrum owner, scrum master, dev team. each sprint has duration 2
weeks to 1 month. during each sprint there are daily meetings (daily
scrum/standup). meeting before Sprint Planning meeting which finalizes
the backlog/work items planned for that sprint. at the end there is
retrospective meeting analyzes success points and "improvement area"
process intended to reveal flaws in the security mechanisms of an information wireshark, nessus, nexpose, metasploit,
security testing
system that protect data and maintain functionality as intended. whitehat, burp suite,
preliminary testing to reveal simple failures severe enough to (for example) reject test core functionalities, if it is smoking/broken,
smoke a prospective software release stop, return to devs, else continue testing

protocol specification for exchanging structured information in the implementation


soap
of web services in computer networks.
stress to understand the upper limits of capacity within the system
validates a program by checking it against the published user or system
system testing
requirements
Requirements are turned into very specific test cases, then the software is
test driven development
improved to pass the new tests, only
a software development process that relies on the repetition of a very short
development cycle:
Test-driven development 1. first the developer writes an (initially failing) automated test case that defines a
(TDD) desired improvement or new function,
2. then produces the minimum amount of code to pass that test,
3. and finally refactors the new code to acceptable standards.
unit testing verify the functionality of a specific section of code, usually at the function level nunit
usability testing evaluate a product by testing it on users
an informal, natural language description of one or more features of a software
user story
system
requirment analisys->system design->implementation->testing->deployment-
whaterfall hehehe
>maintenence in that order
tests internal structures or workings of a program, as opposed to the functionality
whitebox
exposed to the end-user
ensures that your application can gracefully handle invalid input or unexpected core difference between {positive testing} and
user behavior. A negative test checks if a application behaves as expected with {negative testing} is that throwing an exception
its negative inputs (invalid data). is not an unexpected event in the latter. When
Negative testing
you perform negative testing, exceptions are
expected – they indicate that the application
handles improper user behavior correctly.
types of testing what it is example
determines that your application works as expected. core difference between {positive testing} and
{negative testing} is that throwing an exception
is not an unexpected event in the latter. When
Positive testing
you perform negative testing, exceptions are
expected – they indicate that the application
handles improper user behavior correctly.
determine when a given test activity should start. It also includes the beginning of
Entry criterion
a level of testing, when test design or when test execution is ready to start.
determine whether a given test activity has been completed or NOT. Exit criteria
Exit criterion can be defined for all of the test activities right from planning, specification and
execution.
req analysis->test planning->test case development->environment setup->test
software testing life cycle execution->test cycle closure
testing process executed in systemic and planned manner
1]High Severity And Low Priority----If there is an application , if that application
crashes after mulple use of any functionality (exa--save Button use 200 times
then that application will crash)
Means High Severity because application chrashed but Low Priority because no
need to debug right now you can debug it after some days.

2]High Priority And Low Severity---- If any Web site say "Yahoo" now if the logo
of site "Yahoo" spell s "Yho" ----Than Priority is high but severity is low.
Because it effect the name of site so important to do quick ---Priority
but it is not going to crash because of spell chage so severity low.

High Priority & High Severity: An error which occurs on the basic functionality of
severityVSpriority
the application and will not allow the user to use the system. (Eg. A site
maintaining the student details, on saving record if it, doesn’t allow to save the
record then this is high priority and high severity bug.)

High Priority & Low Severity: The spelling mistakes that happens on the cover
page or heading or title of an application.

High Severity & Low Priority: An error which occurs on the functionality of the
application (for which there is no workaround) and will not allow the user to use
the system but on click of link which is rarely used by the end user.

Low Priority and Low Severity: Any cosmetic or spelling issues which is within a
paragraph or in the report (Not on cover page, heading, title).

Potrebbero piacerti anche