* most bugs can be found in the initial change of code :
- creation of features
- code changed
- areas that are impacted by the code change indirectly
* Issue that come about from just testing these based on thought:
- missed bugs due to missed testing on impact
* Bugs come from :
* missed conditions
- UI
- human cognitive behavior
- nationality impacts
- universal access
- locale
- conditions and states
* coding errors
Session based testing ( http://en.wikipedia.org/wiki/Session-based_testing ):
* advantages :
- fast testing of areas
- higher bug yield esp on new code change
* disadvantages :
- depends on notes on reproducibility
- depends on state changes
- depends on the testers knowledge of area
- small bug yield gets questioned on how well of a coverage
About Session based:
* outline areas of conditions and states
* figure out high risk areas:
- conditions/states where the coder may have missed considering
- customer work flow
- high area of customer use
- concentration on code change (code coverage)
- direct impact of code change
- indirect code change
Testing in general :
* Critical bugs depends on high knowledge of code design:
- understanding of states esp in the case of multiprocesses
- understanding of memory usage, disk usage, network usage
- the more understanding, the more states and conditions can be tested
(Specs and Code Design helps with understanding these critical areas faster)
* Negative/Positive is as important in testing
- positive testing makes sure the app works as intended
- negative testing makes sure that the app handles errors well
* Testing should be done not only on the test case itself, but around the conditions
of the test case to ensure quality
* Most bugs can be reached in a small number of steps
* Code for a process follows a path
* Multiprocesses leads to different states prior to a particular code process going to a bug
* Automation:
- Used for regression testing of non UI based issues, many varied conditions, and file creation
Advantages:
* used to detect change in the application
* can save time for repetitive tasks
- Benchmarking
- smoke, bfts
* can save time for creation of files/test scenarios
* can save time for varied conditions testing
Disadvantage
* dependent on how well the test case is written
* cost of development of test
* cost of maintenance of test when code changes
* cost of time spent figuring out when something is wrong
- can be alleviated by output from the test
- log of what’s being tested, when, how, outcome
* depends on the test, but have a harder time detecting UI based issues
* cannot test human usability
* Test cases:
Advantages :
* gives a measure and recording of what has been tested
* gives a “spec” of sorts
Disadvantages:
* maintenance cost
* creation cost
* reading and marking test cases causes time being spent from testing
Note: higher bug yield for test cases revolve around testing around the test case with varying condition not just running test cases.
* Performance:
* various benchmarking
* profiling
* Other types of testing:
* Code Coverage Tools?
* Fuzzing (profile, web pages)
* automation on browsing/creation various types of html pages? (dynamic)
Note: the more detailed test cases created (automation or manual), the more likelihood of duplications test cases/effort and the higher the cost for maintenance, running, creation
