Showing posts with label Software testing. Show all posts
Showing posts with label Software testing. Show all posts

Sunday, August 4, 2019

Manual Testing




Manual Testing is a sort of Software Testing where Testers physically/manually execute test cases without using any automation tool for executing test cases/scripts. Manual Testing is the most crude of all testing forms and helps discover bugs in the software product .

Any new application must be manually tested before its testing is being automated. Manual Testing requires more exertion yet is important to check automation possibility.

One of the Software Testing Fundamental is "100% Automation is beyond the realm of imagination".

Types of Manual Testing

  1. Black Box Testing
  2. White Box Testing
  3. Unit Testing
  4. System Testing
  5. Integration Testing
  6. Acceptance Testing

Step by step instructions to perform Manual Testing

  • Analyse, Study and comprehend the  software product documentation/guidelines. Likewise, study the Application Under Test (AUT) if accessible. 
  • Write Test cases that describes all the requirements referenced in the documentation. 
  • Review the test cases with Team Lead, Client (as appropriate) 
  • Execute the test cases on the AUT 
  • Report bugs. 
  • When bugs are fixed, again execute the test cases to confirm they pass. 


Share:

Friday, August 2, 2019

Difference between alpha and beta testing

Alpha and Beta Testing has different meanings to different professionals. Alpha testing is the acceptance testing done at the development site. Some organizations have a different meaning of alpha testing. They consider alpha testing as
testing which is conducted on early, unstable versions of software. On the contrary beta testing is acceptance testing conducted at the clients end.In short, the only difference between beta testing and alpha testing is the location
where the testing process is being done.
Alpha and Beta Testing

                                                      


x
Share:

Monday, June 24, 2019

What Is Static Testing & Dynamic Testing?

Static Testing


It does not require any execution of the application under test in order to validate the functionality against the requirement. Its done by the testers and developers during the documentation (Requirement gathering and analysis,Making BRD,SRS,FRD) phase. It is more cost effective as compared to dynamic testing. It covers large area as compare to dynamic testing.










Dynamic Testing

It requires an execution of the application under test in order to validate the functionality against the requirement  by entering the input and validating the output with the expected result.





Share:

Saturday, June 8, 2019

Advantages and Disadvantages of V-model

Advantages of V-model:

• Simple and easy to use. Testing activities like planning, test designing happens well before coding. This saves a lot of time. Hence higher chance of success over the waterfall model.
• Proactive defect tracking – that is defects are found at early stage.
• Avoids the downward flow of the defects.
• Works well for small projects where requirements are easily understood.



Disadvantages of V-model:

• Very rigid and least flexible.
• Software is developed during the implementation phase, so no early prototypes of the software are produced.

When to use the V-model:

• The V-shaped model should be used for small to medium sized projects where requirements are clearly defined and fixed.
• The V-Shaped model should be chosen when ample technical resources are available with needed technical expertise.
Share:

Sunday, June 2, 2019

Types of Verification

As we know that Verification is basically reviewing any application without running it.
So we can do verification in two ways. Namely, Walkthroughs & Inspection.

Broadly speaking Walkthroughs are informal way of verification wherein we ask our colleague or we can our self verify the documentation & coding.

On the other hand, Inspection is a Formal & Official way of Verifying. For Example, an organisation may have a separate team for carrying out inspection by  verifying design documents for every project.Every project needs to go through this process and if there is any mistake in design document then the project will get non conformance list and for proceeding further every project needs to go through this.






Share:

Wednesday, May 29, 2019

Prioritization of Tests


Prioritization of Tests :

Why do we need to Prioritize ?

  1.  Time constraints
  2.  Resource Constraints
  3.  We need to get the best done in the time available
  4. How do we Prioritize?
  5. Identification of the Most Important Tests first(MITs)

Basis of Prioritization of Tests:

  1.  Business complexity.
  2.  Severity of potential failure
  3.  Visibility of failure
  4.  Likelihood of error
  5.  User requirements and priorities
  6.  Technical complexity and complexity
  7.  Contractual requirements / Compliance requirement

Share:

The Psychology of Software Testing



The Psychology of Testing

  •  Building the software requires a different mindset from testing the software.
  •  Building is aimed to solve problems with testing is to look for defects (find problems) in software.
  •  Programmers and Testers are two separate roles, although programmers do test code.
  •  Test independence avoids author bias and is often more effective at finding defects and failures.
  •  Developers view : Testing is the process to prove that software works correctly.
  •  QA view : Testing is the process to prove that software does not work.
  •  Manager’s View : Testing is the process to detect the defects and minimize the risk associated with the residual defects.

Why do we test? 

  1.  Primarily to find faults in the software
  2.  This can be perceived as being a destructive process, not constructive
  3.  How does this fit with the mind set of the developer and tester ?


 Tester-Developer relationships:

Communication is the Key !!
  1.  Must be constructive not destructive
  2.  Developers must inform testers of any changes made to the system
  3.  Testers must report problems to developers clearly and concisely.
It is a two-way process !!


Test Independence:

Independent testing is more effective.
  1.  Author should not test their own work.
  2.  The author should not test their own work
-Assumptions made are carried into testing
-People see what they want to see
-There can be emotional attachment with the product
-We’re human

Levels of Independence

  1. Where test cases are
  2.  designed by the person who writes the software under test (v.v.low)
  3.  designed by another person(low)
  4.  designed by people from another department (medium)
  5.  designed by people from another organisation (very medium)
  6.  not chosen by a person (v.v.high)

Testers characteristics:

  1.     Methodical
  2.     Happy when they are finding faults
  3.     Under-valued by the organisation
  4.     Not always intended to be a tester
  5.     Good communicators
  6.     Need to be multi-talented
  7.     Tact & diplomacy are essential

Developer characteristics :

  1.  Specialized
  2.  Creative
  3.  Valued by the organisation
  4.  Trained
  5.  Sensitive to criticism
Share:

Software Testing Life Cycle / Fundamentals Test Process



Fundamentals of Software Testing  Process/ STLC



1.Test Planning:

1.Determine the scope and risks and identify the objectives of testing.
2. Determine the test approach
3. Implement the test policy and/or the test strategy.
4. Determine the required test resources.
5. Schedule test analysis and design task, test implementation, execution
and evaluation.
6. Determine the exit criteria


2. Test Control:


1. Measure and analyse the results of reviews and testing.
2. Monitor and document progress, test coverage and exit criteria.
3. Provide information on testing.
4. Initiate corrective actions.

3. Test Analysis & Design:


1.Review test basis (such as product risk analysis, requirements, architecture, design specs) that help us build our tests.
2. Identify gaps and ambiguities in the specifications.
3. Identify test conditions – high level list of what are we interested in testing.
4. Evaluate test-ability of the requirement and system – ex: if performance of the software is important , that should be specified in a testable way.
5. Design the test environment set-up and identify and required infrastructure and tools.


4. Test Implantation:


1. Develop and prioritize our test cases, using the techniques and create test data.
2. Priority of test cases, decided during test planning should be taken in account.
3. Create test suites from test cases for efficient test execution.
4. Test suite is a logical collection of test cases which naturally work together.
5. Implement and verify the environment – make sure appropriate hardware and
software has been set up.

5. Test Execution:


1. Execute the test suites and individual test cases, this can be done manually or using automated tools.
2. Log the outcome of the test execution and record identities.
3. Logging should be done for each and every test case run for success or failure. This can be use for test analysis.
4. Re-execute tests to confirm fix, also called as re-testing.

6. Evaluating exit criteria and reporting:


1. Evaluating exit criteria is the activity where test execution is assessed against the objectives.
2. This should be done fir each test level
Ex : Exit criteria for unit testing:
a) all unit test cases are executed.
b) No open defects exists in the unit.
3. It’s very important to collect metrics in order to decide the end of the test
4. May require change in test plan ex: addition of resources, addition/deletion of tests.

7. Test Closure:


1. Major activity is to collect data from completed test activities. ( Test results/notes of unexpected events ).
2. Finalize and archive test ware, such as scripts, test environments, and any test infrastructure.
3. Hand over test-ware to the maintenance organisation.
4. Analyse lessons learned for future releases and projects.
Share:

General Software Testing Principles



There are 7 Principles related to software testing:

  • Principle 1- Testing shows presence of defects
  • Principle 2- Exhaustive testing is impossible
  • Principle 3- Early testing
  • Principle 4- Defect clustering
  • Principle 5- Pesticide Paradox
  • Principle 6- Testing is context dependent
  • Principle 7- Absence-of-errors fallacy
Detailed explanation 


Principle 1- Testing shows presence of defects : The principle arises from the theory of the process of scientific experimentation has been adopted by testers;

Testing can only prove the presence of defects, never their absence.
The aim of testing is to make the software fail by finding bugs.In case testers are unable to find defects after repeatedly doing regression testing doesn’t mean that the software is bug-free.

Principle 2- Exhaustive testing is impossible :Testing everything (all combinations of inputs and preconditions) is not feasible except for trivial cases. Instead of exhaustive testing, we use risks and priorities to focus testing efforts.
For example, nuclear power installations, air traffic control systems and fly-by-wire systems. Indeed, it is important that these systems are tested more thoroughly than most; but exhaustive testing is not possible.
Example : A simple function adds two 32 bit numbers and returns a result Assumption:1000 test cases can be executed per second.
Principle 3- Early testing:Testing activities should start as early as possible in the software development. Early testing such as early test design and review activities finds defects early on when are cheap to find and fix.
Early testing has following advantages:
a. Early preparation of test environment, thereby preventing any delays and
unknown risks will have enough time to deal with.
b. If you complete test cases early you will have a baseline. If there are changes
later , problem will be easy to detect by comparing it with baseline.
c. You will have time to Quantify the problem's scope.
d. You may find that few items may not be tested , since they may not be
impacted. This input can cut down on your Testing phase.
e. There is usually tendency to squeeze the testing time. This may impact
Quality. But if you start testing early , you may not need to squeeze your time.
Principle 4 - Defect clustering :A small number of modules contains most of the defects discovered during pre-release testing or show the most operational failures.
In most cases, it can be seen that the majority of the detected defects are caused by a small number if modules.
All of us experience traffic congestion's. Typically, during these congestion's, we will see a convoy effect. There will be stretches of roads with very heavy congestion's, with vehicles looking like
they are going in a convoy. This will be followed by a stretch of smooth sailing (rather , driving) until we encounter the next convoy.
Principle 5 - Pesticide Paradox: If the same tests are repeated over and over again , eventually the same set of test cases will no longer find any new bugs.
To overcome this ‘pesticide paradox’, the test cases need to be regularly reviewed and revised, and new and different tests need to be written to exercise different parts of the software.
Example : If you keep applying the same pesticide , the insects eventually build up resistance and the pesticide no longer works.
Principle 6 - Testing is context dependent: Not all software systems carry same level of risk and not all problems have the same Impact when they occur.
Example : Safety –critical software is tested differently from an e-commerce site.
Principle 7- Absence-of-errors fallacy: Finding and fixing defects does not help if the system built is unusable and does not fulfill the users needs and expectations.




Share:

Tuesday, May 28, 2019

What is Quality Management, Quality Control & Quality Assurance ?




Quality Management: Responsible choosing the correct process to ensure that the product is ‘fit for purpose’.


  • A predictable degree of uniformity and dependability at low cost and
  • suited to the market (Dr. Edward Deming).
  • Degree to which a set of inherit character tics fulfills the requirements
  • (ISO-9000)
  • Meeting the customer requirements first time and every time which is fit
  • for use to its intended functions with reasonable cost and within in time.
  • Quality must be measurable and should predictable.
  • Quality must be well defined and should be quantified
  • Quality objective should be achievable and traceable.
  • Quality is Value , Value = Utility (Fit for Purpose) + Warranty (Fit for Use)
  • Utility = What customer wants / Warranty = How it is delivered.
  • ISO9126 – Quality Standard ( The standard is divided into four parts : Quality model , Internal metrics, External metrics , Quality in use metrics)


Quality Control : “ is the activity performed to ensue that a Product is ‘fit for Purpose’ “.

1. Concentrates on specific products.
2. Defect – detection and correction oriented.
3. Usually done after the product is built.
4. This is usually a line function.
5. Examples : Software testing at various levels.

Quality Assurance: “is the activity performed to test the process is being followed”
1. Concentrates on the process of producing the products
2. Defect – prevention oriented
3. Usually done throughout the life cycle.
4. This is usually a staff function.
5. Examples : Reviews and Audits
Share:

Relationship between Software Testing and Quality?





  • “ Testing identifies faults and whose removal increases software quality by increasing the software’s potential reliability “.
  • Testing increases software quality.
  • Testing is the measurement of software quality.
  • “ We measure how closely we have achieved quality by testing the relevant factors such as Correctness, Reliability, Usability, Maintainability etc.”
  • Share:

    Wednesday, May 22, 2019

    What is priority and severity of a bug?

    Image result for software testing priority

    Severity of a bug defines how critical is the impact of the bug on the software module/system is. If the Severity of any bug is high then its priority will also be high and vice-versa.
    Severity has 4 types :Critical,Major,Medium and Low Priority of a software bug  can be defined as the order in which a bug should get fixed. Higher the priority the sooner the defect should be resolved.
    Priority has 3 types: High,Medium and Low.

    Share:

    Monday, May 20, 2019

    What are Quality Assurance and Quality Control in Software Testing?




    Quality Assurance in software involves activities related to the process of building a software.This approach used to prevent the defect in the process of developing software and application.


    Quality Control in software is a product oriented approach towards building a software product. It requires the execution of the code or program in order to find the bugs in the software or an application.
    Share:

    Saturday, May 18, 2019

    What Is Software Testing ?




    • Software testing is the process of verifying and validating a software product against the requirement of the client. It can alternatively be defined as the process of finding bugs in the software product in order to improve the quality of the software.
    • Testing is questioning a product in order to evaluate it.
    • Software testing is the process used to help identify the correctness,completeness, security and quality of developed computer software.

    • Testing the test-ability of the product is called software testing.
    Share:

    Email Subscription

    Enter your email address:

    Delivered by FeedBurner

    Follow my blog

    Total Pageviews

    Contact Form

    Name

    Email *

    Message *

    Translate