Beruflich Dokumente
Kultur Dokumente
For Web Applications what type of tests are you going to do?
Web-based applications present new challenges, these challenges include:
- Short release cycles;
- Constantly Changing Technology;
- Possible huge number of users during initial website launch;
- Inability to control the user's running environment;
- 24-hour availability of the web site.
The quality of a website must be evident from the Onset. Any difficulty whether in
response time, accuracy of information, or ease of use-will compel the user to click to a
competitor's site. Such problems translate into lost of users, lost sales, and poor
company image.
3. Navigation Testing
Good Navigation is an essential part of a website, especially those that are complex and
provide a lot of information. Assessing navigation is a major part of usability Testing.
4. Forms Testing
Websites that use forms need tests to ensure that each field works properly and that the
forms posts all data as intended by the designer.
8. Performance Testing
Performance Testing, which evaluates System performance under normal and heavy
usage, is crucial to success of any web application. A system that takes for long to
respond may frustrate the user who can then quickly move to a competitor's site. Given
enough time, every page request will eventually be delivered. Performance testing seeks
to ensure that the website server responds to browser requests within defined
parameters.
9. Load Testing
The purpose of Load testing is to model real world experiences, typically by generating
many simultaneous users accessing the website. We use automation tools to increases
the ability to conduct a valid load test, because it emulates thousand of users by sending
simultaneous requests to the application or the server.
CEG:
A testing technique that aids in selecting, in a systematic way, a high-yield set of test
cases that logically relates causes to effects to produce test cases. It has a beneficial
side effect in pointing out incompleteness and ambiguities in specifications.
Password is having 6 digit alphanumeric then what are the possible input
conditions?
Including special characters also Possible input conditions are:
1) Input password as = 6abcde (ie number first)
2) Input password as = abcde8 (ie character first)
3) Input password as = 123456 (all numbers)
4) Input password as = abcdef (all characters)
5) Input password less than 6 digit
6) Input password greater than 6 digits
7) Input password as special characters
8) Input password in CAPITAL ie uppercase
9) Input password including space
10) (SPACE) followed by alphabets /numerical /alphanumerical/
If we have no SRS, BRS but we have test cases does you execute the test cases blindly
or do you follow any other process.
Test case would have detail steps of what the application is supposed to do.
1) Functionality of application.
2) In addition you can refer to Backend, is mean look into the Database. To gain more
knowledge of the application.
Smoke test? Do you use any automation tool for smoke testing?
Testing the application whether it's performing its basic functionality properly or not, so
that the test team can go ahead with the application. Definitely can use.
What is Testing environment in your company, means how testing process start?
Testing process is going as follows:
Quality assurance unit
Quality assurance manager
Test lead
Test engineer
Give an example of high priority and low severity, low priority and high severity?
Severity level:
The degree of impact the issue or problem has on the project. Severity 1 usually means
the highest level requiring immediate attention. Severity 5 usually represents a
documentation defect of minimal impact.
Severity is levels:
• Critical: the software will not run
• High: unexpected fatal errors (includes crashes and data corruption)
• Medium: a feature is malfunctioning
• Low: a cosmetic issue
Severity levels
1. Bug causes system crash or data loss.
2. Bug causes major functionality or other severe problems; product crashes in
obscure cases.
3. Bug causes minor functionality problems, may affect "fit anf finish".
4. Bug contains typos, unclear wording or error messages in low visibility fields.
Severity levels
• High: A major issue where a large piece of functionality or major system
component is completely broken. There is no workaround and testing cannot
continue.
• Medium: A major issue where a large piece of functionality or major system
component is not working properly. There is a workaround, however, and testing
can continue.
• Low: A minor issue that imposes some loss of functionality, but for which there is
an acceptable and easily reproducible workaround. Testing can proceed without
interruption.
Severity and Priority
Priority is Relative: the priority might change over time. Perhaps a bug initially deemed
P1 becomes rated as P2 or even a P3 as the schedule draws closer to the release and
as the test team finds even more heinous errors. Priority is a subjective evaluation of
how important an issue is, given other tasks in the queue and the current schedule. It’s
relative. It shifts over time. And it’s a business decision.
Severity is an absolute: it’s an assessment of the impact of the bug without regard to
other work in the queue or the current schedule. The only reason severity should change
is if we have new information that causes us to re-evaluate our assessment. If it was a
high severity issue when I entered it, it’s still a high severity issue when it’s deferred to
the next release. The severity hasn’t changed just because we’ve run out of time. The
priority changed.
S2 - Medium/Workaround. Exist like when a problem is required in the specs but tester
can go on with testing. Incident affects an area of functionality but there is a work-around
which negates impact to business process. This is a problem that:
a) Affects a more isolated piece of functionality.
b) Occurs only at certain boundary conditions.
c) Has a workaround (where "don't do that" might be an acceptable answer to the user).
d) Occurs only at one or two customers. or is intermittent
S3 - Low. This is for minor problems, such as failures at extreme boundary conditions
that are unlikely to occur in normal use, or minor errors in
layout/formatting. Problems do not impact use of the product in any substantive way.
These are incidents that are cosmetic in nature and of no or very low impact to business
processes.
TASK: Procedures.
e.g. Preparation of HLD, LLD etc.
If you take .NET Application, Presentation (ASP, HTML, DHTML), Business Tier (DLL) &
Data Tier ( Database like Oracle, SQL Server etc.,)
Client Server Applications: It will have only 2 tiers. One is Presentation (Java, Swing)
and Data Tier (Oracle, SQL Server). If it is client Server architecture, the entire
application has to be installed on the client machine. When ever you do any changes in
your code, Again, It has to be installed on all the client machines. Where as in Web
Applications, Core Application will reside on the server and client can be thin
Client(browser). Whatever the changes you do, you have to install the application in the
server. NO need to worry about the clients. Because, You will not install any thing on the
client machine.
The main metrices are :size,shedule,defects.In this there are main sub metrices.
Test Coverage = Number of units (KLOC/FP) tested / total size of the system
Test cost (in %) = Cost of testing / total cost *100
Cost to locate defect = Cost of testing / the number of defects located
Defects detected in testing (in %) = Defects detected in testing / total system
defects*100
Acceptance criteria tested = Acceptance criteria tested / total acceptance criteria
What are the main bugs which were identified by you and in that how many are
considered as real bugs?
If you take one screen, let's say, it has got 50 Test conditions, out of which, I have
identified 5 defects which are failed. I should give the description defect, severity and
defect classfication. All the defects will be considered.
What is TRM?
TRM means Test Responsibility Matrix.
TRM: --- It indicates mapping between test factors and development stages...
What are the differences between these three words Error, Defect and Bug?
Error: The deviation from the required logic, syntax or standards/ethics is called as error.
Bug: if the defect is agreed by the developer then it converts into bug, which has to fix by
the developer or post pond to next version.
Database Approach : In this approach, all application access a common database, which
is a centralized data storage system.
Functions of a DBMS :
Function of DBMS Description Provided by using
Defining the data structure Defining structure of data to be stored in database Data
Definition Language (DDL)
Manipulating Data Retrieving, adding, modifying, deleting data. Data Manipulation
Language (DML)
Data Security Preventing unauthorized access to data. User-ids and Passwords.
Control of Data Access Allowing users to use only relevant data Data Control Language
(DCL).
Relation : A relation stores information about an object in the real world. A relation is
represented as a table.
Types of Entities : Entities can be classified in two ways - based on existence and based
on subsets.
Based on existence, entities can be classified as Dominant and Weak entities.
Based on subsets, entities can be classifies as Supertypes and Subtypes.
Types of Relationships : Relationships are classified into three types based on the
occurrence of the related entities. One-to-One(1-1), One-to-Many(1-M) & Many-to-
Many(M-M).
Using E/R Diagram : A E/R diagram represent entities and relationships in a database
system.
Conversion from 1NF to 2NF : To convert a relation in 1NF to 2NF, move all nonkey
attributes that are not wholly dependent on the primary key, to a new relation. Then,
choose an appropriate primary key for the new relation. E.g. Separating Sup. table and
Item table.
Conversion from 2NF to 3NF : To convert a relation in 2NF to 3NF, move all transitively
dependent attributes to a new relation. Then, choose an appropriate primary key for the
new relation. E.g. Status is dependent on City in Sup. table, so move those two to
separate table.
Simplifying Data to 4NF (Isolate Independent Multiple Relationships) :
Answer2:
HTML ( H yper T ext M arkup L anguage) is the language used to write Web pages.
You are looking at a Web page right now.
You can view HTML pages in two ways:
* One view is their appearance on a Web browser, just like this page -- colors,
different text sizes, graphics.
* The other view is called "HTML Code" -- this is the code that tells the browser what
to do.
2. What is a tag?
In HTML, a tag tells the browser what to do. When you write an HTML page, you enter
tags for many reasons -- to change the appearance of text, to show a graphic, or to
make a link to another page.
Browser Display:
This is my message to the world!
An HTML comment begins with "<!--", ends with "-->", and does not contain "--" or ">"
anywhere in the comment.
The following are examples of HTML comments:
<table>
<tr>
<td>this is the first cell of the outer table</td>
<td>this is the second cell of the outer table,
<FORM ACTION="[URL]">
<TABLE BORDER="0">
<TR>
<TH>Account:</TH>
<TD><INPUT TYPE="text" NAME="account"></TD>
</TR>
<TR>
<TH>Password:</TH>
<TD><INPUT TYPE="password" NAME="password"></TD>
</TR>
<TR>
<TD> </TD>
<TD><INPUT TYPE="submit" NAME="Log On"></TD>
</TR>
</TABLE>
</FORM>
<div class="center">
<table>...</table>
</div>
div.center {
text-align: center;
}
div.center table {
margin-left: auto;
margin-right: auto;
text-align: left;
}
13. How do I use forms?
The basic syntax for a form is: <FORM ACTION="[URL]">...</FORM>
When the form is submitted, the form data is sent to the URL specified in the ACTION
attribute. This URL should refer to a server-side (e.g., CGI) program that will process
the form data. The form itself should contain
<script type="text/javascript">
document.myform.myinput.focus();
</script>
A similar approach uses <body onload=...> to set the focus, but some browsers seem
to process the ONLOAD event before the entire document (i.e., the part with the form)
has been loaded.
18. How can I eliminate the extra space after a </form> tag?
HTML has no mechanism to control this. However, with CSS, you can set the margin-
bottom of the form to 0. For example:
<form style="margin-bottom:0;" action=...>
You can also use a CSS style sheet to affect all the forms on a page:
form { margin-bottom: 0 ; }
1. The browser strips everything after the last slash in the base document's URL and
appends the relative URL to the result.
2. Each "." segment is deleted (e.g., ./all.html is the same as all.html, and ./ refers to
the current "directory" level in the URL hierarchy).
3. Each ".." segment moves up one level in the URL hierarchy; the ".." segment is
removed, along with the segment that precedes it (e.g., foo/../all.html is the same as
all.html, and ../ refers to the parent "directory" level in the URL hierarchy).
Some examples may help make this clear. If the base document is
<URL:http://www.yoursite.com/faq/html/basics.html>, then
Please note that the browser resolves relative URLs, not the server. The server sees
only the resulting absolute URL. Also, relative URLs navigate the URL hierarchy. The
relationship (if any) between the URL hierarchy and the server's filesystem hierarchy
is irrelevant.
24. Why doesn't <TABLE WIDTH="100%"> use the full browser width?
Graphical browsers leave a narrow margin between the edge of the display area and
the content.
Also note that Navigator always leaves room for a scrollbar on the right, but draws the
scrollbar only when the document is long enough to require scrolling. If the document
does not require scrolling, then this leaves a right "margin" that cannot be removed.
25. Why is there extra space before or after my table?
This is often caused by invalid HTML syntax. Specifically, it is often caused by loose
content within the table (i.e., content that is not inside a TD or TH element). There is
no standard way to handle loose content within a table. Some browsers display all
loose content before or after the table. When the loose content contains only multiple
line breaks or empty paragraphs, then these browsers will display all this empty space
before or after the table itself.
The solution is to fix the HTML syntax errors. All content within a table must be within
a TD or TH element.
Send me email at
<A HREF="mailto:me@mydomain.com">me@mydomain.com</A>.
27. How can I have two sets of links with different colors?
You can suggest this presentation in a style sheet. First, specify colors for normal
links, like this:
Next, identify the links that you want to have different colors. You can use the CLASS
attribute in your HTML, like this:
Alternatively, you can identify an element that contains the links that you want to have
different colors, like this:
<div class="example2">...
<a href="[URL]">[link text]</a>...
<a href="[URL]">[link text]</a>...
<a href="[URL]">[link text]</a>...
</div>
Then, in your style sheet, use a selector for links in this containing element, like this:
28. How can I show HTML examples without them being interpreted as part of
my document?
Within the HTML example, first replace the "&" character with "&" everywhere it
occurs. Then replace the "<" character with "<" and the ">" character with ">" in
the same way.
Note that it may be appropriate to use the CODE and/or PRE elements when
displaying HTML examples.
29. How do I get special characters in my HTML?
The special case of the less-than ('<'), greater-than ('>'), and ampersand ('&')
characters. In general, the safest way to write HTML is in US-ASCII (ANSI X3.4, a 7-
bit code), expressing characters from the upper half of the 8-bit code by using HTML
entities.
Working with 8-bit characters can also be successful in many practical situations: Unix
and MS-Windows (using Latin-1), and also Macs (with some reservations).
Latin-1 (ISO-8859-1) is intended for English, French, German, Spanish, Portuguese,
and various other western European languages. (It is inadequate for many languages
of central and eastern Europe and elsewhere, let alone for languages not written in
the Roman alphabet.) On the Web, these are the only characters reliably supported.
In particular, characters 128 through 159 as used in MS-Windows are not part of the
ISO-8859-1 code set and will not be displayed as Windows users expect. These
characters include the em dash, en dash, curly quotes, bullet, and trademark symbol;
neither the actual character (the single byte) nor its &#nnn; decimal equivalent is
correct in HTML. Also, ISO-8859-1 does not include the Euro currency character.
(See the last paragraph of this answer for more about such characters.)
On platforms whose own character code isn't ISO-8859-1, such as MS-DOS and Mac
OS, there may be problems: you have to use text transfer methods that convert
between the platform's own code and ISO-8859-1 (e.g., Fetch for the Mac), or convert
separately (e.g., GNU recode). Using 7-bit ASCII with entities avoids those problems,
but this FAQ is too small to cover other possibilities in detail.
If you run a web server (httpd) on a platform whose own character code isn't ISO-
8859-1, such as a Mac or an IBM mainframe, then it's the job of the server to convert
text documents into ISO-8859-1 code when sending them to the network.
If you want to use characters not in ISO-8859-1, you must use HTML 4 or XHTML
rather than HTML 3.2, choose an appropriate alternative character set (and for certain
character sets, choose the encoding system too), and use one method or other of
specifying this.
31. Posting Copy and Paste HTML
For those wanting to post direct Copy and Paste HTML on screen without the use of
spaces or *s etc. and the need to explain those substitutions: Use < to substitute for
each opening tag < in each tagged set of HTML. Example, typing the following: <a
href="http://www.yourname.com"><img
src="http://pics.yourname.com/aw/pics/mask.gif"></a> Will show up on screen as:
<a href="http://www.yourname.com"><img
src="http://pics.yourname.com/aw/pics/mask.gif"></a>
61. What is the difference between the HTML form methods GET and POST?
The method parameter specifies which method the client is using to send information
to the WEB server. The method determines which parameter you will find the CGI
request data in:
* POST - post_args
* GET - http_search_args
62. How do I rename all the files from .htm to .html after copying them from a PC
to a UNIX machine?
UNIX's mv (`move') command won't handle wildcard filenames. However, there's a
program called htmaddl (for `HTM-add-"L"'), so you can login and type htmaddl. This
will rename all .htm files to .html
If you haven't got this program on your UNIX machine, you can type it into a file called
htmaddl:
#! /bin/sh
for f in *.htm; do
base=`basename $f .htm`
mv $f $base.html
done
After saving it and exiting your editor, make it executable by typing the command
chmod ugo+x htmaddl
Best of all, move it into your ~/bin directory, or ask your WebMeister to put it in
/usr/local/bin so everyone can use it.
2. Numbered Lists: <ol> begins a numbered, indented list. Each item in the list is then
prefaced with the <li> tag. You need to close the list with the </ol> tag. Note: You can
expand the <ol> to specify the TYPE of numbering:
Database Testing
An2:
Re-execution of our test with different input values is called Re-testing. In validate our
Project calculations, test engineer follows retesting manner through automation
tool.Re-teting is also called DataDriven Test.There are 4 types of datadriven tests.
1) Dynamic Input submissiion ( key driven test) : Sometines a test engineer conducts
retesting with different input values to validate the calculation through dynamic
submission.For this input submission, test engineer use this function in TSL scriipt--
create_input_dialog ("label");
2) Data Driven Files Through FLAT FILES ( .txt,.doc) : Sometimes testengineer
conducts re-testing depends on flat file contents. He collect these files from Old
Version databases or from customer side.
3)Data Driven Tests From FRONTEND GREAVES : Some times a test engineer
create automation scripts depends on frontend objects values such as (a) list (b)
menu (c) table (d) data window (5) ocx etc.,
4)Data Driven Tests From EXCEL SHEET : sometimes a testengineer follows this
type of data driven test to execute their script for multiple inputs. These multiple inputs
consists in excel sheet columns. We have to collect this testdata from backend
tables .
8. How to test a DTS package created for data insert update and delete? What
should be considered in the above case while testing it?What conditions are to
be checked if the data is inserted, updated or deleted using a text files?
Data Integrity checks should be performed. IF the database schema is 3rd normal
form, then that should be maintained. Check to see if any of the constraints have
thrown an error. The most important command will have to be the DELETE command.
That is where things can go really wrong.
Most of all, maintain a backup of the previous database.
1. If your application provides view functionality for the entered data, then you can
verify that from front end only. Most of the time Black box test engineers verify the
functionality in this way.
2. If your application has only data entry from front end and there is no view from front
end, then you have to go to Database and run relevent SQL query.
11. How do you test whether the database is updated as and when an
information are added in the front end?Give me an example?
It depends on what level of testing you are doing.When you want to save something
from front end obviously, it has to store somewhere in the database
You will need to find out the relevant tables involved in saving the records.
Data Mapping from front end to the tables.Then enter the data from front end and
save.
Go to database, fire queries to get the same date from the back end.
An3:
Data bas testing basically include the following.
1)Data validity testing.
2)Data Integritity testing
3)Performance related to data base.
4)Testing of Procedure,triggers and functions.
for doing data validity testing you should be good in SQL queries
For data integrity testing you should know about referintial integrity and different
constraint.
For performance related things you should have idea about the table structure and
design.
for testing Procedure triggers and functions you should be able to understand the
same.
An2:
To write testcase for database its just like functional testing.
1.Objective:Write the objective that you would like to test. eg: To check the shipment
that i load thru xml is getting inserted for perticular customer.
2.Write the method of input or action that you do. eg:Load an xml with all data which
can be added to a customer.
3.Expected :Input should be viewd in database. eg: The shipment should be loaded
sucessfully for that customer,also it should be seen in application.4.You can write
ssuch type of testcases for any functionality like update,delete etc.
An3:
At first we need to go through the documents provided.
Need to know what tables, stored procedures are mentioned in the doc.
Then test the functionality of the application.
Simultaneously, start writing the DB testcases.. with the queries you have used at the
backend while testing, the tables and stored procedures you have used in order to get
the desired results. Trigers that were fired. Based on the stored procedure we can
know the functionality for a specific peice of the application. So that we can write
queries related to that. From that we make DB testcases also.
An2:
Database tests are supported via ODBC using the following functions:
SQLOpen, SQLClose, SQLError, SQLRetrieve, SQLRetrieveToFile, SQLExecQuery,
SQLGetSchema and SQLRequest.
You can carry out cursor type operations by incrementing arrays of returned datasets.
All SQL queries are supplied as a string. You can execute stored procedures for
instance on SQL Server you could use “Exec MyStoredProcedure” and as long as that
stored procedure is registered on the SQL Server database then it should execute
however you cannot interact as much as you may like by supplying say in/out
variables, etc but for most instances it will cover your database test requirements
An3:
Data bas testing basically include the following.
1)Data validity testing.
2)Data Integritity testing
3)Performance related to data base.
4)Testing of Procedure,triggers and functions.
for doing data validity testing you should be good in SQL queries
For data integrity testing you should know about referintial integrity and different
constraint.
For performance related things you should have idea about the table structure and
design.
for testing Procedure triggers and functions you should be able to understand the
same.
An4:
Data base testing generally deals with the follwoing:
a)Checking the integrity of UI data with Database Data
b)Checking whether any junk data is displaying in UI other than that stored in
Database
c)Checking execution of stored procedures with the input values taken from the
database tables
d)Checking the Data Migration .
An2:
Database testing involves some indepth knowledge of the given application and
requires more defined plan of approach to test the data. Key issues include :
1) data Integrity
2) data validity
3) data manipulation and updates.
Tester must be aware of the database design concepts and implementation rules
Other Interview Questions
CSS (Cascading Style Sheets) is a technical specification that allows HTML document authors to
attach formatting style sheets to HTML documents. When HTML documents are viewed as Web
pages through Web browsers, the attached style sheets will alter the default style sheets embedded
in browsers.
One of the fundamental features of CSS is that style sheets cascade; authors can attach a preferred
style sheet, while the reader may have a personal style sheet to adjust for human or technological
handicaps. The rules for resolving conflicts between different style sheets are defined in CSS
specification.
CSS specification is maintained by W3C. You can download a copy of the specification at
http://www.w3.org/.
Tutorials below are based Cascading Style Sheets, level 1, which has been widely accepted as the
current standard.
The basic unit of CSS is a definition of a style property for a selected HTML tag written in the
following syntax:
html_tag_name {style_property_name: style_property_value}
For example:
/* set background color to black for the <BODY> tag */
BODY {background-color: black}
/* set font size to 16pt for the <H1> tag */
H1 {font-size: 16pt}
If you want to include CSS inside a HTML tag, you can use the STYLE attribute as <TAG
STYLE="css_definition" ...>. Of course, the CSS definition will only apply to this instance of this
tag. The following tutorial exercise shows you how to set background to gray on a <PRE> tag:
<p>Map of commonly used colors:</p>
<pre style="background-color: gray">
black #000000
white #ffffff
gray #7f7f7f
red #ff0000
green #00ff00
blue #0000ff
</pre
If you want to include CSS inside the HEAD tag and apply to the entire HMTL docuemnt, you can
use the STYLE tag as <STYLE TYPE="text/css">css_definition</STYLE>. The following
tutorial exercise shows you how to set body background to black and paragraph text to yellow:
<html><head>
<title>CSS Included</title>
<style type="text/css">
BODY {background-color: black}
P {color: yellow}
</style>
</head><body>
<p>Welcome to FYICenter.com.
You should see this text in yellow on black background.</p>
</body></html>
If you want to share a set of CSS definitions with multiple HTML documents, you should those
CSS definitions in an external file, and link it to those HTML documents using the LINK tag in
the HEAD tag as:
<HEAD>
...
<LINK REL=stylesheet TYPE="text/css" HREF="css_file_url"/>
...
</HEAD>
Below is a CSS file called, fyiCenter.css, that stores the same CSS definitions used in the previous
exercise:
BODY {background-color: black}
P {color: yellow}
If you modify the HTML document with the LINK tag instead of the STYLE tag, you can get the
same result:
<html><head>
<title>CSS Linked</title>
<link rel=stylesheet type="text/css" href="fyiCenter.css"/>
</head><body>
<p>Welcome to FYICenter.com.
You should see this text in yellow on black background.</p>
</body></html>
If you define a style property for a HTML tag, this definition will apply to all instances of that tag
in the entire document. If you want to apply different style property values to different instances of
the same tag, you need to use the tag selection mechanisms defined in CSS:
• Tag Selector - Selects all instances of a HTML tag.
• Contextual Selector - Selects all instances of a HTML tag nested inside other specified tags.
• Class Selector - Selects all HTML tags that matches the class name defined in the tag attribute
of class="class_name".
• ID Selector - Selects all HTML tags that matches the id name defined in the tag attribute of
id="id_name".
• Group Selector - Selects multiple HTML tags.
• Mixed Selector - Selects instances of HTML tags mixed with other selectors.
What Is a Class Selector?
A class selector selects all HTML tags that matches the class name defined in the tag attribute of
class="class_name". Class selectors are specified with a leading dot like (.class_name). For
example, the following CSS definition uses a class selector:
/* set text to italic to all tags with class="quote" */
.quote {font-style: italic}
If you apply the above CSS definition to the following HTML document, you will get two blocks
in italic, one from the <p> tag and one from the <pre> tag:
<p>Normal paragraph...</p>
<p class="quote">Special paragraph...</p>
<pre>Normal pre-formatted text...</pre>
<pre class="quote">Special pre-formatted text...</pre>
What Is an ID Selector?
A ID selector selects all HTML tags that matches the id name defined in the tag attribute of
id="id_name". ID selectors are specified with a leading hash like (#id_name). For example, the
following CSS definition uses an ID selector:
/* set text to red to all tags with id="onSale" */
#onSale {color: red}
If you apply the above CSS definition to the following HTML document, you will get two blocks
in red, one from the <p> tag and one from the <pre> tag:
<p>Normal paragraph...</p>
<p id="onSale">Special paragraph...</p>
<pre>Normal pre-formatted text...</pre>
<pre id="onSale">Special pre-formatted text...</pre>
A contextual selector selects a HTML tag that is nested inside another specified tag. Contextual
selectors are specified with two tags separated with a space like (outer_tag inner_tag). For
example, the following CSS definition uses a contextual selector:
/* set paragraph inside a table to use arial font family */
FORM P {font-family: arial}
If you apply the above CSS definition to the following HTML document, you will get the search
instruction block in "arial" font family:
<form action=search.cgi>
<p>Search instruction...</p>
<input type=submit value=Search>
</form>
A group selector selects multiple HTML tags. Group selectors are specified with multiple tags
separated with a comma like (tag, tag, tag). For example, the following CSS definition uses a
group selector:
/* set background color to gray for all instances
of three tags: <UL>, <OL>, and <DL> */
UL, OL, DL {background-color: gray}
A mixed selector is a selector that uses a combination of all other selectors. The following CSS
shows some good examples:
/* selects <p class="quote"> tags */
P.quote {font-style: italic}
Pseudo classes are classes used by Web browsers to differentiate statuses of a HTML tag. CSS
definitions can use pseudo classes as selectors with a leading colon like (:visited). There are 3
pseudo classes on the <A> tag:
• A:link - A hyper link that has not been visited.
• A:visited - A hyper link that has been visited before.
• A:active - A hyper link that is currently under the mouse pointer.
If you want to the alter the default style sheets of the browser, you could define something like
this:
/* show un-visited links in blue */
A:link {color: blue}
If you have multiple CSS definitions to be applied to the same HTML tag, you can write them
together delimited with semicolon (;). The following CSS provides you a good example of CSS
definition groups:
pre.code {background-color: #efefef; width: 502px;
margin: 4px; padding: 4px}
Style property Inheritance is a rule that allows a style property of a child HTML tag to inherit the
same property of the parent HTML tag, if that property is not defined on the child tag. This
inheritance rule is very important because a lots of style properties are defined on the parent tags
and inherited to the child tags. The CSS below shows you how to define most of the font
properties on <P> tags and let <STRONG> and <EM> to inherit them:
<html><head>
<title>CSS Included</title>
<style type="text/css">
BODY {background-color: black}
P {font-family: arial; font-size: 12pt; color: yellow}
STRONG {font-weight: bold}
EM {font-style: italic}
</style>
</head><body>
<p>Welcome to <strong>FYICenter.com</strong>.
You should see this text in <em>yellow</em>
on black background.</p>
</body></html>
As you can, the font family, size and color in <STRONG> and <EM> are inherited from <P>.
CSS cascading is another rule that allows multiple definitions on the same style property of the
same HTML tag instance. The Web browser will use cascading order rules to determine the
winning definition. Multiple definitions of the same property could happen because:
• Multiple CSS files can be attached to a single HTML document.
• CSS selectors can overlap on HTML tag instances.
• External CSS definitions can mixed with CSS definitions included inside HTML Tag
instances.
Note that cascading order rules are applied in the order as listed above.
The top white space of your Web page is provided by the browser's default CSS definition of the
margin-top property on the BODY tag. You can remove this white space by adding your own
margin-top definition. Because of the cascading order rules, your definition wins over the default
definition. Here is a CSS example:
<html><head>
<title>CSS Included</title>
<style type="text/css">
BODY {margin-top: 0px}
BODY {background-color: white}
P {font-family: arial; font-size: 12pt; color: black}
</style>
</head><body>
<p>Welcome to FYICenter.com.<br>
This paragraph should appear right below the top edge
of the browser window without any white space.</p>
</body></html>
If want to set the text font inside tables different than outside tables, you can use CSS definitions
with contextual selectors. In the CSS example below, Both selectors "TABLE P" and "P" match
those <P> tags inside the table, but the contextual selector "TABLE P" wins the tag selector "P"
based on the cascading order rules. So you will see text inside the table in blue "serif":
<html><head>
<title>CSS Included</title>
<style type="text/css">
/* matches P instances inside TABLE only */
TABLE P {margin-top: 0px; margin-left: 20px;
font-family: serif; font-size: 12pt; color: blue}
A more reliable way to identify tag instances is to use the class attributes and class selectors. In the
CSS example below, class="url" is added to <P> tags for Web addresses, with a new CSS
definitions using a class selector "P.url". All three selectors match the Web address text, but the
class selector "P.url" wins because of the cascading order rules. So you will see Web addresses in
bold "sans-serif":
<html><head>
<title>CSS Included</title>
<style type="text/css">
/* matches P instances with class="url" only */
P.url {margin-top: 0px; margin-left: 20px;
font-family: sans-serif; fond-weight: bold}
/* matches P instances inside TABLE only */
TABLE P {margin-top: 0px; margin-left: 40px;
font-family: serif; font-size: 12pt; color: blue}
Note that Web address is displayed in blue. Why? Because color is not defined with "P.url", so
"TABLE P" wins the color definition.
Class is a nice way to separate a group of tag instances. To identify one or two special instances,
you can use the ID attributes and ID selectors. In the CSS example below, the ID selector "P#hot"
wins over all other selectors, so the third row in the table will be in red:
<html><head>
<title>CSS Included</title>
<style type="text/css">
/* matches P instances with id="hot" only */
P#hot {color: red}
Many of the process models currently used can be more generally connected by the
V-model where the “V” describes the graphical arrangement of the individual phases.
The “V” is also a synonym for verification and validation.
The model is very simple and easy to understand. By the ordering of activities in time
sequence and with abstraction levels the connection between development and test
activities becomes clear. Oppositely laying activities complement one another i.e.
serve as a base for test activities. So, for example, the system test is carried out on
the basis of the results specification phase. The coarse view of the model gives the
impressionthat the test activities first start after the implementation. However, in the
description of the individual activities the preparatory work is usually listed. So, for
example, the test plan and test strategy should be worked out immediately after the
definition of the requirements. Nevertheless it can contribute very well to the
structuring of the software development process.
The disadvantage of the model is the coarse division into constructive work (including
the implementation) on the left-hand side of the “V” and the more destructive tasks on
the right-hand side. Here also the impression may develop that, after the
implementation phase, a ready product can be delivered. A planned-in removal of
defects and regression test is not given.
From the view of testing, all of the models presented previously are deficient in
various ways:
• the test activities first start after the implementation
• the connection between the various test stages and the basis for the test is not clear
• the tight link between test, debug and change tasks during the test phase is not clear
In the following, the W-model is presented. This is based on the general V-model and
the disadvantages previously mentioned are removed.
The test process usually receives too little attention in the models presented and
usually appears as an unattractive task to be carried out after coding. In order to place
testing on an equal footing, a second “V” dedicated to testing is integrated into the
model. Both “V”s together give the “W” of the Wmodel.
What are the Quality Assurance and Software Configuration Management roles
and responsibilities with Extreme Programming?
We prefer for there to be a separate organization for functional testing (probably
exactly like your QA function, with testing results made public very quickly). XP,
however, only says that there must be functional tests: it does not specify
organizationally how they must be done. Experience is that testing is best done by a
separate function - but one that is very tightly integrated with development rather than
at the end of a long pipeline.
Configuration management is also up to the team. It is usually necessary to have one
or more individuals responsible for CM. We have no special rules or practices
addressing how a group would manage the requirement to build multiple systems
from one code base. Our main approach would be: for each release configuration,
there must be corresponding functional tests, and these must be run before that
configuration is released to the (real) customer. We would think that development
would proceed by running kind of a "union" of all the functional tests of all the
configurations.
We'd probably have to talk more specifically about how your specific organization
needs to build configurations to say much more about that.
How can a person write storyboards without having the basics of pinpointing
and developing sound requirements?
Do you use IEEE, SEI, ISO9000 standards as references to acquire the fundamentals
of defining accurate requirements for customers and software engineering users?
How can a person write storyboards without having the basics of pinpointing and
developing sound requirements?
We would agree that those who play the customer role have to know what they want.
We do not, however, recommend any particularly formal requirements writing or
recording mechanism. Instead, what we are working toward (XP is for small teams,
after all) is to have a clear understanding in the heads of customers, developers, and
testers as to what is wanted.
Rather than have, say, an "analyst" sit down with the customer and laboriously
translate his mumblings into something representing what is wanted, and then having
a "designer" take the analysis and build a design, and so on, small teams function
best if the customers and designer/developers talk to one another until they develop a
common vocabulary of what is needed and how it will be done. In XP, we would like to
have a common level of understanding in all heads, each focused on its own
particular interests:
Customers: what's needed, what's the business value, when do we need it?
Developers: what's needed, how can I build this, how can I test my code, how long will
it take?
Testers: what's needed by the customers, how can I test whether developers have
done it?
As you can see, the testers' functional tests are what close the loop, assuring
everyone that what was asked for was what we got. The best way to do XP is with a
separate functional testing organization that is closely integrated into the process. It
would be delightful to have that organization run by an experienced QA manager
trained in XP.
OPERATING SYSTEM?
The syslogd daemon is responsible for tracking system information and saving it to
specified log files.
GUI - Short for Graphical User Interface, a GUI Operating System contains graphics
and icons and is commonly navigated by using a computer mouse. See our GUI
dictionary definition for a complete definition. Below are some examples of GUI
Operating Systems.
System 7.x
Windows 98
Windows CE
Multi-user - A multi-user Operating System allows for multiple users to use the same
computer at the same time and/or different times. See our multi-user dictionary
definition for a complete definition for a complete definition. Below are some examples
of multi-user Operating Systems.
Linux
Unix
Windows 2000
Windows XP
Mac OS X
Linux
Unix
Windows 2000
Windows XP
Mac OS X
Unix
Windows 2000
Windows XP
Mac OS X
Linux
Unix
Windows 2000
Windows XP
Mac OS X