How to be with Development Team?

1) Be neutral with your views.
2) Distribute the bitter flavor in a sweet-coated capsule.
3) Aim to go up against your valuable points at the requirements phase.
4) Sustain a sugary language while discussions.
5) While partying, involve freely with them.
6) Pointlessly, don’t exchange a lot of rigid expressions.
7) In vital circumstances, administer the stuffs in an apt way.
8) Sharing the sensible thoughts (or) suggestion.
9) In a roundabout way, shoot the blunders committed by them.
10) Make an effort to avoid miscommunication & get a good name from them.

Response Time, Throughput and Utilization

(a) Response Time
Response Time is the delay experienced when a request is made to the server and the server's response to the client is received. It is usually measured in units of time, such as seconds or milliseconds.

(b) Throughput
Throughput refers to the number of client requests processed within a certain unit of time. Typically, the unit of measurement is requests per second or pages per second. From a marketing perspective, throughput may also be measured in terms of visitors per day or page views per day.

(c) Utilization
Utilization refers to the usage level of different system resources, such as the server's CPU(s), memory, network bandwidth, and so forth. It is usually measured as a percentage of the maximum available level of the specific resource. Utilization versus user load for a Web server typically produces a curve.

Alpha, Beta & Gamma

Alpha Testing: Alpha Testing is mostly like performing usability testing which is done by the in-house developers who developed the software or testers. Sometimes this Alpha Testing is done by the client or an outsider with the presence of developer and tester. The version release after alpha testing is called Alpha Release.

Beta Testing: Beta Testing is done by limited number of end users before delivery, the change request would be fixed if the user gives feedback or reports defect. The version release after beta testing is called Beta Release.

Gamma Testing: Gamma Testing is done when the software is ready for release with specified requirements. This testing is done directly by skipping all the in-house testing activities.

Prologue >> Automation Testing

What is Automation Testing?

Test automation is the use of software to control the execution of tests, the comparison of actual outcomes to predicted outcomes, the setting up of test preconditions, and other test control and test reporting functions. Commonly, test automation involves automating a manual process already in place that uses a formalized testing process.

Test automation involves automating a manual process already in place that uses a formalized testing process.

Benefits of Automation

Reliable: Tests perform precisely the same operations each time they are run, thereby eliminating human error.

Repeatable: You can test how the software reacts under repeated execution of the same operations.

Programmable: You can program sophisticated tests that bring out hidden information from the application.

Comprehensive: You can build a suite of tests that covers every feature in your application.

Reusable: You can reuse tests on different versions of an application, even if the user interfaces changes.

Better Quality Software: Because you can run more tests in less time with fewer resources

Fast: Automated Tools run tests significantly faster than human users.

Cost Reduction: As the number of resources for regression test are reduced.

Other: Test without any human interaction

Why Automation is required?

Ø Reducing test time and resources

Ø Consistent Test Procedures

Ø Ensures process repeatability and resource independence

Ø Eliminates errors of manual testing

Ø Improves efficiency of testing

Ø Reducing testing costs

Ø Gives consistent and accurate results

When to automate?

Ø Regression testing

Ø Data-driven testing

Ø The Application under manual test is stable

Ø Application which has long runs

Regression Testing: Regression test suite is the best candidate for automation. If testing only needs for short period projects, it should be done manually. If the test suite needs to be run for a long time, regularly for every iteration, build and after bug fixing, then it should be automated. Always automate Smoke test cases then Sanity test cases and then regression.

Data-driven testing: Single test to verify multiple data like want to test application with various users.

The Application under manual test is stable: We cannot automate application which is unstable i.e when the functionality of application keeps on changing.

Long Run Projects: Long run projects are good to go with automation. Automating short duration project does not make sense. I personally go for automation for those projects whose duration is more than 6 months.

When to NOT Automate?

Ø Functionality of the application changes frequently

Ø Project doesn’t have enough time

Ø Test with unknown results cannot be automated

Smoke Vs Sanity

	Smoke	Sanity
1	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.	A Sanity test is a narrow regression test that focuses on one or a few areas of functionality. Sanity testing is usually narrow and deep.
2	A Smoke test is scripted--either using a written set of tests or an automated test.	A Sanity test is usually unscripted.
3	A Smoke test is designed to touch every part of the application in a cursory way. It's is shallow and wide.	A Sanity test is used to determine a small section of the application is still working after a minor change.
4	Smoke testing will be conducted to ensure whether the most crucial functions of a program work, but not bothering with finer details. (Such as build verification).	Sanity testing is a cursory testing; it is performed whenever a cursory testing is sufficient to prove the application is functioning according to specifications. This level of testing is a subset of regression testing.
5	Smoke testing is normal health check up to a build of an application before taking it to testing in depth.	Sanity testing is to verify whether requirements are met or not, checking all features breadth-first.

Static Testing Vs Dynamic Testing

Static Testing

The Verification activities fall into the category of Static Testing. During static testing, you have a checklist to check whether the work you are doing is going as per the set standards of the organization. These standards can be for Coding, Integrating and Deployment. Reviews, Inspections and Walkthroughs are static testing methodologies.

Dynamic Testing

Dynamic Testing involves working with the software, giving input values and checking if the output is as expected. These are the Validation activities. Unit Tests, Integration Tests, System Tests and Acceptance Tests are few of the Dynamic Testing methodologies.

For example: Inspecting a car without running is the static testing while test driving a car is the dynamic testing.

Buggy Application (or) Software ?

Question: Is your "Software/Application" diseased?

>>> Then there are a few causes for unhealthiness. They are as follows;

1. Breakdown in informational exchange.
2. Unrealistic development time-frame.
3. Deprived design logic.
4. Feeble coding ethics.
5. Lack of version control.
6. Less focus on documentation maintenance.
7. Infectious third-party devices.
8. Less attention on software repairs.
9. End-line Alterations.
10. Individual Traits.

URL(another place where my blog got posted) :: Application-Diseased

5 C's of Software Testing Techniques

Context – Context is King of the testing cards.

· Software Testing is always context dependent.

· In general, for jointly operating environment, we need to have a clear context.

· When people work together, the main segment is the “Project’s Context”.

· It desires to be perfect. No matter what the format is, if context is not appropriate, all will lead to failure / fault.

Consistency – Consistency is Queen of testing cards.

· The consistency in Software Testing can be viewed as application’s effectiveness. It is consistent user experience.

· A consistent tester is a tester, who has a well-versioned test cases and test suite.

· Testing is a steady approach which helps the planning better.

· The text’s position and fonts in an application needs to be consistent in all the browsers.

Correctness – Correctness is Jack of testing cards.

· Correctness is the essential purpose of Software Testing.

· Correctness is to tell the right action from the wrong one.

· Validating the correctness with various inputs is what inspired to be testing.

· Primary correctness should take place as earliest possible which leads testing as uncomplicated.

Communication – Communication is Joker of testing cards pack.

· Communication plays a vital role in Software Testing.

· A tester should have strong communication skill, since your points need to be noticed.

· You should be able to express your views effectively with regards to the bug tracking.

· Communication operates as a chief mediator in traceability matrix as its aiding customer relationship management and commitment negotiation.

Company (or) Community – Company (or) Community is Ace of testing cards.

· Testing Communities/Testing Companies moves the Software Testing to next level.

· Through Communities and Companies, the students from schools & colleges know how important and elegant the Software Testing is. We can see 'N' number of individual companies for Software Testing nowadays.

· The Software Testing market offers huge opportunities for both pure plays testing as well as IT service companies.

· Testing companies & communities are initiating more conferences to make Software Testing the center of attraction in IT.

URL(another place where my blog got posted) :: 5 C's of Software Testing

Automation & Mind

Automation testing started. What are all in my (your) mind?

· Is application stable?

· Need to analyze the requirement.

· What are the pages/modules involved.

· What manipulation happens to the data?

· What kind of framework need to be implemented?

· Need to improve in-depth knowledge of the domain.

· Will my framework applicable for web application?

· What are the field validations?

· Where is information stored in the database?

· Questions related to object handling in the application.

· Are the business rules that manage the process?

Epitome of Testing

For those who are not familiar with the word ‘Epitome’, it’s nothing but “Essence”.

As a person in a QA/Tester role there are a number of typical roles that can be approved.

• Sheriff – Bringing order to the Wild West. Chaotic development processes are roped in and consistency and discipline instilled in the vacuum.

• Cheerleader – Pumping the team up to be more than they are. ‘Better unit tests? Way to go’

• Cop – More or less the opposite of the Cheerleader. While typically you get more flies with honey, sometimes you do have to bring out the vinegar.

• Negotiator – An active role in figuring out the trade-offs between development and test.

• Marketer – A longer-term variation of the Negotiator which uses more subtle techniques for furthering agenda.

• Coach – Strategist and morale support.

Testing is Hyped

• Good QA testers are worth their weight in gold.

• Unit testing finds certain errors; manual testing others; usability testing and code reviews still others.

• The peer pressure of knowing your code will be analyzed on providing higher quality.

• Another huge problem with developer tests is that they won’t tell you if your software sucks

• No single technique is effective at detecting all defects.

• Testers are a developer’s editor.

OSDLC

MaximuM ExposurE (M2M - E2E)
OSDLC [Original Software Development Life Cycle]

1. Development team constructs a code that they believe it’s a bug-free.

2. The build is tested and 15 bugs are recognized by testing team and 5 are known issues from the dev team.

3. Programmer resolves 10 of the bugs and clarifies to the testing team that the other 5 aren't actually bugs.

4. Testing team finds that 5 of the fixes didn't work as anticipated and notices 15 fresh set of bugs.

5. Recursion for steps 3 and 4.

6. Since there are various marketing demands and a really untimely product declaration based on overly-optimistic programming schedule, the product is released by pushing the code into the production instance.

7. Users locate 125 new bugs which has some domain issues which we never consider as a bug.

8. Original developers are cashed for their great work, is nowhere to be found in that office surroundings.

9. Newly accumulated programming group fixes almost all of the 125 issues but brings in 350 new ones.

10. Original developers more often visits that product’s testing team and enquires about the good and bad things about that product. [At some point, the entire testing department quits.]

11. The company might be traded by the competitor using earnings from their latest release, which had 500 bugs.

12. New CEO is taken place in by the board of directors. He employs a set of programmer to recreate the product from the square-one & an automation test groups for regression process.

13. New Development team constructs a code that they believe it’s a bug-free.