Software Testing

We do Independent Validation and Testing services such as product life cycle testing, security testing. With our specialized test engineers and facilities, Veritas IT understand it very well. We have deep expertise and experience in application development.

Software testing as a separate process requires close integration with the core project work starting from the early stages. We achieve this through our emphasis on close relationships with, and attention to, the customers and their needs. Siloon enables clients to concentrate their own time and resources for high-level tasks, as well as lower the operating costs related to acquiring and maintaining necessary infrastructure.

Veritas IT offers a full range of Testing Services from simple manual testing to complex automated testing.

We at Veritas IT provide an objective, independent view of the software to allow the business to appreciate and understand the risks of software implementation. Test techniques include the process of executing a program or application with the intent of finding software bugs (errors or other defects), and to verify that the software product is fit for use.

Software testing involves the execution of a software component or system component to evaluate one or more properties of interest. In general, these properties indicate the extent to which the component or system under test:

1. meets the requirements that guided its design and development
2. responds correctly to all kinds of inputs
3. performs its functions within an acceptable time, is sufficiently usable
4. can be installed and run in its intended environments, and achieves the general result its stakeholders desire.

All software testing uses some strategy to select tests that are feasible for the available time and resources. As a result, software testing typically (but not exclusively) attempts to execute a program or application with the intent of finding software bugs (errors or other defects). The job of testing is an iterative process as when one bug is fixed, it can illuminate other, deeper bugs, or can even create new ones.

Software testing can provide objective, independent information about the quality of software and risk of its failure to users and/or sponsors.

Software testing can be conducted as soon as executable software (even if partially complete) exists. The overall approach to software development often determines when and how testing is conducted. For example, in a phased process, most testing occurs after system requirements have been defined and then implemented in testable programs. In contrast, under an Agile approach, requirements, programming, and testing are often done concurrently.

Testing methods
Static vs. dynamic testing
There are many approaches available in software testing. Reviews, walkthroughs, or inspections are referred to as static testing, whereas actually executing programmed code with a given set oftest cases is referred to as dynamic testing. Dynamic testing takes place when the program itself is run.

Dynamic testing may begin before the program is 100% complete in order to test particular sections of code and are applied to discrete functions or modules. Typical techniques for this are either using stubs/drivers or execution from a debugger environment.

Static testing is often implicit, as proofreading, plus when programming tools/text editors check source code structure or compilers (pre-compilers) check syntax and data flow as static program analysis.

Static testing involves verification, whereas dynamic testing involves validation. Together they help improve software quality. Among the techniques for static analysis, mutation testing can be used to ensure the test cases will detect errors which are introduced by mutating the source code.

The box Approach
Software testing methods are traditionally divided into white- and black-box testing. These two approaches are used to describe the point of view that a test engineer takes when designing test cases.

White-box testing (also known as clear box testing, glass box testing, transparent box testing and structural testing, by seeing the source code) tests internal structures or workings of a program, as opposed to the functionality exposed to the end-user.

While white-box testing can be applied at the unit, integration and system levels of the software testing process, it is usually done at the unit level. It can test paths within a unit, paths between units during integration, and between subsystems during a system-level test. Though this method of test design can uncover many errors or problems, it might not detect unimplemented parts of the specification or missing requirements.

Techniques used in white-box testing include
API testing - testing of the application using public and private APIs (application programming interfaces)

Code coverage - creating tests to satisfy some criteria of code coverage (e.g., the test designer can create tests to cause all statements in the program to be executed at least once)

Fault injection methods - intentionally introducing faults to gauge the efficacy of testing strategies

Black-box testing Black-box testing treats the software as a "black box", examining functionality without any knowledge of internal implementation, without seeing the source code. The testers are only aware of what the software is supposed to do, not how it does it.

Black-box testing methods include: equivalence partitioning,boundary value analysis, all-pairs testing, state transition tables, decision table testing, fuzz testing, model-based testing, use case testing, exploratory testing and specification-based testing.

Visual testing
The aim of visual testing is to provide developers with the ability to examine what was happening at the point of software failure by presenting the data in such a way that the developer can easily find the information she or he requires, and the information is expressed clearly.

By knowing the underlying concepts of how the software works, the tester makes better-informed testing choices while testing the software from outside.

Testing levels
There are two different levels of tests from the perspective of customers: low-level testing (LLT) and high-level testing (HLT). LLT is a group of tests for different level components of software application or product. HLT is a group of tests for the whole software application or product.[citation needed]

Integration testing
Integration testing is any type of software testing that seeks to verify the interfaces between components against a software design. Software components may be integrated in an iterative way or all together ("big bang"). Normally the former is considered a better practice since it allows interface issues to be located more quickly and fixed.

Component interface testing
The practice of component interface testing can be used to check the handling of data passed between various units, or subsystem components, beyond full integration testing between those units.

System testing
System testing tests a completely integrated system to verify that the system meets its requirements

Operational acceptance testing
Operational acceptance is used to conduct operational readiness (pre-release) of a product, service or system as part of a quality management system. OAT is a common type of non-functional software testing, used mainly in software development and software maintenance projects. This type of testing focuses on the operational readiness of the system to be supported, and/or to become part of the production environment

Our approach to software testing can assist clients to take advantage of critical information which could be used to:

• Test automation framework
• Redefine the application / software development process
• In-depth knowledge of the focus domains
• Identify areas of weakness and enhancements
• World class testing tools for productivity improvement
• Verify the expected performance
• Transparency in testing process and reporting
• Ensure that business requirements of the system have been met
• Reduced total cost of ownership
• Verify the accuracy of logic
• Accelerated time-to-market
• Ready-made test suits to jump-start testing process
• Reduce rework that is needed to fix buggy software.