What is SEI,CMM,CMMI and ISO

SEI:

Software Engineering Institute. It is Active development of the model by the US Department of Defence Software Engineering Institute (SEI) began in 1986.

CMM:

Capability Maturity Model. The term maturity relate to the degree of formality and optimization of processes. There are five levels defined in CMM.

Level 1: Initial  - It is the starting point for use of a new or undocumented repeat process.

Level 2: Repeatable - the process is at least documented sufficiently such that repeating the same steps may be attempted.

Level 3: Defined - the process is defined/confirmed as a standard business process, and decomposed to levels 1, 2 and 3.

Level 4: Managed - the process is quantitatively managed in accordance with agreed-upon metrics.

Level 5: Optimizing - process management includes deliberate process optimization/improvement.

CMMI:

Capability Maturity Model Integration . It is a process improvement approach that helps organizations improve their performance. CMMI can be used to guide process improvement across a project, a division, or an entire organization. It’s integrate traditionally separate organizational functions, set process improvement goals and priorities, provide guidance for quality processes, and provide a point of reference for appraising current processes.

ISO:

International Organization for Standards ISO 9000 is a series of standards, developed and published by the International Organization for Standardization, The ISO 9000 standard is the most widely known and It serves many different industries and organizations as a guide to quality products, service, and management.  In order to be certified, the organization must submit to an examination by an outside assessor.

Difference between Cookie and Cache

NO	Cookie	Cache
1	Cookie is a very small piece of information that is stored on the client’s machine by the web site and is sent back to the server each time a page is requested	Cache is a temporary storage of web page resources stored on client’s machine for quicker loading of the web pages.
2	Cookie is to store information to track different characteristics related to user	Cache is to make the loading of web pages faster
3	Cookies keep information such as user preferences	Cache will keep resource files such as audio, video or flash files.
4	Cookies expire after some time	Cache is kept in the client’s machine until they are removed manually by the user.

Tips for Bug Investigation

1       Analysis the software bug cause:

Find the real cause of the software bug;  that cause can be software design, code implementation, tester fault etc.

2       Investigate any other similar types of the bug:

Sometime it’s happen that the symptoms are different but cause is same. Or that bug may be find out the different area of the software system.

3       Check the symptoms of the bugs:

What are the symptoms of the stated bug that need to be check.

4       Reproduce the same bug:

Try to reproduce same bug with same environment which is stated on the bug report.

5       Check  the possible side effect:

Sometime some bug responsible to indicate possible side effects. These could be file corruptions, device failure etc.

6       Communicate with Team members:

Communication is very important. Communicate with them who are familiar of the system. They may be able to provide you some useful information and tips. Even they can provide you possible side effect.

7       Create new test and new data for the bug:

Creating new data, editing test script is useful to check the bug.

8       Report the bug:

       It is very important if you are doing bug investigation reporting the each test important because it can be useful and helpful too.

List of HTTP Status Code

HTTP is request-response protocols. Every HTTP transaction has a status code .So for doing web application testing tester need to understand following status code too. Some of status codes are very common that are: 200,300,301,302,304,307,400,401,403,404,500,501,503.

List of HTTP Status Code:

1xx status code represents the information message

Eg:
100-Continue
101-Switching Protocols
103-Checkpoints

2xx status code represents the Successful message

Eg:
200- OK
201-Created
202-Accepted
203-Non Authoritative information
204-No content
205-Reset content
206-Partial content

3xx status code represents the Redirection message

Eg:
300-Multiple choice-Max 5 address
301-Moved permanently
302-Found (Moved temporally)
303-See Other
304-Not modified
306-Switch proxy (No longer used)
307-Temporally redirects
308-Resume incomplete

4xx status code represents the Client Error message

Eg:
400-Bad Request
401-Unauthorized
402-Payment required(Use in future)
403-Forbidden (Server refuse the request)
404-Not found (Request page not found currently but it available in future)
405-Method not allowed
406-Not acceptable
407-Proxy authentication required
408-Request timeout
409-Conflict
410-Request page is no longer available
411-Length required
412-Precondition failed
413-Request Entry to large
414-Request URL too long
415-Unsupported media type
416-Requested range not satisfied
417-Expectation failed

5xx status code represents the Server Error message

Eg:
500-Internal server Error
501-Server does not recognize request method or it may not be fulfil the request
502-Bad getaway
503-Server is down or overloaded
504-Getaway timeout
505-Http version not supported
511-Network authentication required

Selenium Command-3A

Selenium IDE Features

Software Testing Estimation

Estimation is important factor which associate with each project .The same thing associate to the testing task, testing team that how much time do they required to do testing activity.

Estimation should not be wrong or not to be irrelevant. Test Estimation should be realistic.

In testing there are number of activity need to do like requirement analysis, test planning, test case writing, test case executions, regression testing and all.

To define the test estimation tester has to understand the requirement clearly when project requirement take place.
Need to allocate the task properly. Task should be divide in such way that everyone occupy with proper task and that lead to complete the testing activity in allocated time here you need to understand  Members skill ,expertise which help to estimate the how much time requires to writing, executing test cases etc. See every test team member has their own speed like someone is faster than other to do testing activity.

 (Resources Availability like members presence)To do test Estimation should consider team member availability for particular testing task so that will help to allocating the task accurately.

If new feature is developed understand that feature properly .or if there enhancement is going on existing product then take help of last version project test cases ,script which will be help to do parallel testing.

Test Estimation  judgments come with the experience with previous project.

Bug checking ,regression testing is purely depend upon the size of the project .If more number of the featured develop the chances of bug and checking of the bug fixing more so it may be spoil the testing timeline so you need to be take buffer time for that so you can do this type of testing activity too.

Communication is very important factor, do not hesitate to take the help of and communicate with the team member, developer because at end the project needs to be complete given timeline with quality.

Requirement analysis : Why it is important?

Requirement analysis is very crucial part in testing and it is core activity of the tester.
Tester need to understand the requirements clearly. If there is bigger requirement that need to be split in small requirements and need to be work on it.

The requirement has to be clear, readable, understandable, traceable, and measurable.

If we say requirement clear that mean there is no confusion .If we say readable that mean any non-technical person need to be understand requirement .There is no any unnecessary technical term and It is easy to understand.

The Requirement should be measurable that mean no any assumption .For e.g. take web application if user enter the search term then application need to response as soon as possible. Seeing this requirement we can’t understand what exactly it mean? "as soon as possible" .does it response in 1min,60 sec or in 30 sec ? so there is need to be a specific time in which we can measure the response.

Requirement should be traceable with different level that mean it can be traceable to design level, coding or Testing level.
When we say traceable in testing that mean each Requirement has their own testcase.That requirement need to be traceable to their respective test cases.

The Requirements are key factor for the tester.

Communication is more important, if you do not understand any requirement ask the question until you understand requirements clearly.

Change in requirement: sometimes it happens the requirement get change so in that case it has to be defined process for receiving the new requirement and Ensure that the new requirement request is it approval from all stakeholder.

Difference between Thin Client & Thick Client

NO	Thin Client	Thick Client
1	In Thin Client, Application actually run on the server where Server situated anywhere	In Thick Client, Application Actually run on the Client and little work done on the server if needed.
2	Thin Client is also called as Small Client	Thick Client is also called as Fat Client.
3	Thin Client require constant communication with server	Thick Client no need require constant communication with server
4	Less security threats	More Security issues
5	More downtime require	Very expensive to deploy
6	Little data processing done in client machine	More data processing done in Client machine
7	Thin Client Require more server demand	Thick Client Require less server demand
8	E.g.: Browser Base Application	E.g.: Windows base Application

Exploratory Testing

Exploratory Testing:

Explore the word itself indicate research, investigate the new thing which you don’t know .When exploring the new thing somehow you enhancing your knowledge and it is kind of the learning.

You can do exploring testing the way you want it is purely depend upon you; there is neither typical process nor any pattern.

Next question come that when we will do the exploratory testing? Exploratory testing done at any stage of testing .E.g.: reviewing the requirements, reviewing test cases.

When test case reviewing take place the testers gather together they give their own ideas,inputs,they share their knowledge so that means they exploring test case for the particular requirements.

Learning about new product new feature it is an exploratory activity when people learn(Explore) the new product they might be take the help of other people guidance, they might use present document or else self-directed.

When you are exploring you are investigating you are discovering.

Exploratory testing is how you are going to do, how you are going to learn new thing.

Difference between Alpha Testing and Beta Testing

NO	Alpha Testing	Beta Testing
1	Alpha testing is a UAT testing done at Developers site	Beta  testing is a UAT testing done at customer site
2	Developer available at that time	Developer may not be available that time customer need to report the defect and Developer need to be fixed that defect
3	Alpha testing done in virtual enviornment	Beta testing done in Real environment
4	Alpha testing is final testing before the software release to general public	Beta testing or Beta version of software released to group of people ,general public to receive feedback from them

To do Negative Testing positively

Why we do the negative testing. Why it is important?

Negative testing is testing which attempts to shows that application or module does not do anything which is not supposed to do.

But how we can do the Negative testing.

See Negative testing is a core skill. It is powerful approach. It is very important how effectively you do negative testing

Many people have different meaning about negative testing Even they have their own views also.

But for me Negative Testing is more about :

To do thing which is not written in the requirement?

It is about imagination

Exploring the product

Find out the problem, Fault

Let say the requirement is: Password should take minimum 8 characters.

If I want to do negative test for that. Then I will check what will be happen if I enter 7 characters?

What will happen if I enter more than 8 characters?

What will happen if enter the only number or I enter only special character?

So this is like I am doing negative test for that requirement

Negative testing mean you are like investigating more about that requirement, you are doing what you are imaging and what you are exploring about the product.

The good tester is who can break the software who can explore the product, who can find the valuable and good bug.

So do Negative Testing in positive way

Test Coverage

When we start testing there are so many question arises like

How much testing is enough?

When we will say the product is good to go?

How we can assure the quality of the product is good?

When we will have to stop testing?

Is the 100% test coverage is important?

Can we achieve 100% test coverage with in timeline?

When we will say testing is sufficient?

How do we measure the software testing completeness?

See in my point of view we can measure the quality by doing the requirement coverage, defect coverage, code coverage.

When we say requirement coverage that mean how many requirements are get validated? Can all requirements trace the respective test cases? Do all the test cases have passed? In vice versa trace the test cases to the specific requirement that requirement is need to be passed. In short software needs to be tested against the all requirements

In Defect Coverage in need to be known how many defect we found? How many defects has fixed?

Code coverage is all about evaluating the test cases against the actual code. We also do the code coverage by doing statement coverage, decision coverage,

  

 See basically when you execute the test case you are testing the component, feature and requirement too. One test case can cover zero or more component and zero or more requirements.  The term Test Case Coverage means to me a measure of how many of the product requirements are being tested by the defined test cases. It is the testers’ job to define their test cases based on the requirements and the goal should be 100% coverage or close to that.

 Test coverage Formula= (Total no of test case executed/ Total no of test case planned)*100

Test coverage ensure that testing is carried out effectively .

ANT and Build.xml File for the Selenium Project

Ant Build for the Selenium Java Project:

It is open source tool.

Ant can be used to generate the html report and it is run in your same project it can be run it through cmd prompt.

How to make Build .xml file?

1. Right click on the project

2. Go to the new>>file gives the filename as build.xml

Here is my Project Setup for the Ant

Here is Build.xml file Code:

<project name="Selenium" default="usage" basedir=".">

    <property environment="env"/>

  

  <property name="ws.build" value="${basedir}"/>

  <property name="ws.jar" value="D:/Jar file of the selenium"/>

  <property name="test.dest" value="${ws.build}/Build"/>

  <property name="test.src" value="${ws.build}/src"/>

  <property name="test.report" value="D:/Report1"/>

    <path id="testcase.path">

<pathelement location="${test.dest}"/>

<fileset dir="${ws.jar}">

<include name="*.jar"/>

</fileset>

</path>

<path id="test.classpath">

<pathelement location="${ws.jar}"/>

</path>

   <target name="setClassPath" unless="test.classpath">

    <path id="classpath_jars">

    <fileset dir="${ws.jar}" includes="*.jar*"/>

    </path>

<pathconvert pathsep=":"

property="test.classpath"

refid="classpath_jars"/>

</target>

<target name="init" depends="setClassPath">

<tstamp>

<format property ="start.time" pattern="MM/dd/yyyy hh:mm:aa"/>

</tstamp>

<condition property ="ANT"

value="${env.ANT_HOME}/bin/ant.bat"

else="${env.ANT_HOME}/bin/ant">

<os family="windows" />

</condition>

<taskdef name="testng" classpath="${test.classpath}" classname="org.testng.TestNGAntTask" />

</target>

<target name="all">

</target>

  <target name="clean">

    <delete dir="${test.dest}"/>

    </target>

  <target name="compile" depends="init, clean">

<delete includeemptydirs="true" quiet="true">

<fileset dir="${test.dest}" includes="**/*"/>

</delete>

<echo message="making directory..."/>

    <mkdir dir="${test.dest}"/>

<echo message="classpath---------:${test.classpath}"/>

<echo message="compiling......."/>

<javac

debug="true"

destdir="${test.dest}"

srcdir="${test.src}"

target="1.7"

classpath="${test.classpath}"

>

</javac>

 </target>

<target name="build" depends="init">

</target>

<target name="usage">

<echo>

ant run exceute

</echo>

</target>

<path id="test.c">

<fileset dir="${ws.jar}" includes="*.jar"/>

</path>

  <target name="run" >

   <delete includeemptydirs="true" quiet="true">

   <fileset dir="${test.report}" includes="**/*"/>

   </delete>

   <java jar ="${ws.jar}" fork="true" spawn="true"/>

   <junit fork="yes" haltonfailure="no" printsummary="yes">

   <classpath refid="testcase.path" />

   <batchtest todir ="${test.report}" fork="true">

   <fileset dir="${test.dest}">

   <include name="sel.Testcases/FirstTest.class"/>

   <!-- <include name="Testcase/SecoandTest.class"/> 

   -->

   <!-- <include name="Testcase/ThirdTest.class"/>

   -->

   </fileset>

   </batchtest>

   <formatter type="xml"/>

      <classpath refid="testcase.path"/>

   </junit>

   <junitreport todir="${test.report}">

   <fileset dir="${test.report}">

   <include name="**.xml"/>

   </fileset>

   <report todir="${test.report}"/>

   </junitreport>

      </target>

</project>

Related Documents:
ANT Terminology
How to configure ANT in System?
How to make build.xml file?