Thursday 6 September 2018

JSP Scripting Elements

JSP scripting elements let you insert Java code into the servlet that will be generated
from the JSP page. There are three forms:

Expressions of the form <%= Java Expression %>, which are evaluated and inserted into the servlet's output.
Scriptlets of the form <% Java Code %>, which are inserted into the servlet's _jspService method (called by service).
Declarations of the form <%! Field/Method Declaration %>, which are inserted into the body of the servlet class, outside any existing methods.

Expressions

A JSP expression element contains a scripting language expression that is evaluated, converted to a String, and inserted where the expression appears in the JSP file.
Because the value of an expression is converted to a String, you can use an expression within a line of text, whether or not it is tagged with HTML, in a JSP file.
The expression element can contain any expression that is valid according to the Java Language Specification but you cannot use a semicolon to end an expression.
Following is the syntax of JSP Expression:
<%= expression %>
You can write XML equivalent of the above syntax as follows.
<jsp:expression>
expression
</jsp:expression>
Following is the simple example for JSP Expression.
<html>
<head><title>Expression Test</title></head>
<body>
<p>
Today's date is: <%= (new java.util.Date()).toLocaleString()%>
</p>
</body>
</html>
This would generate following result.
Today's date: 11-Sep-2010 21:24:25

Scriptlets

A scriptlet can contain any number of JAVA language statements, variable or method declarations, or expressions that are valid in the page scripting language.
Syntax of Scriptlet:
<% code fragment %>
You can write XML equivalent of the above syntax as follows:

<jsp:scriptlet>
code fragment
</jsp:scriptlet>
Any text, HTML tags, or JSP elements you write must be outside the scriptlet. Following is the simple and first example for JSP:
<html>
<head><title>Hello World</title></head>
<body>
Hello World!<br/>
<%
out.println("Your IP address is " + request.getRemoteAddr());
%>
</body>
</html>

Declarations

A declaration declares one or more variables or methods that you can use in Java code later in the JSP file. You must declare the variable or method before you use it in the JSP file.
Following is the syntax of JSP Declarations:
<%! declaration; [ declaration; ]+ ... %>
You can write XML equivalent of the above syntax as follows:

<jsp:declaration>
code fragment
</jsp:declaration>
Following is the simple example for JSP Declarations.
<%! int i = 0; %>
<%! int a, b, c; %>
<%! Circle a = new Circle(2.0); %>

Enjoy Learning.

Architecture of JSP

A JSP life cycle can be defined as the entire process from its creation till the destruction which is similar to a servlet life cycle with an additional step which is required to compile a JSP into servlet.
JSP follows below steps in its life-cycle-

Compilation
Initialization
Execution
Cleanup

The four major phases of JSP life cycle are very similar to Servlet Life Cycle.

Compilation

When a browser asks for a JSP, the JSP engine first checks to see whether it needs to compile the page. If the page has never been compiled, or if the JSP has been modified since it was last compiled, the JSP engine compiles the page.
Compilation process consists of below three steps:-

Parsing the JSP.
Converting the JSP into a servlet.
Compiling the servlet.

Initialization:

When a container loads a JSP it invokes the jspInit() method before servicing any requests. If you need to perform any custom application specific initialization, then you need to override the jspInit() method.
public void jspInit(){
// Your code here
}
Typically initialization is performed only once and as with the servlet init method. Generally you may like to initialize database connections, open files, and create lookup tables in the jspInit method.

Execution

This phase of the JSP life cycle represents all interactions with requests until the JSP is destroyed.
Whenever a browser requests a JSP and the page has been loaded and initialized, the JSP engine invokes the _jspService() method in the JSP.
The _jspService() method takes an HttpServletRequest and anHttpServletResponse as its parameters as follows:
void _jspService(HttpServletRequest request, HttpServletResponse response) {
// your code
}
In life cycle of JSP, _jspService() method gets invoked once per a request and is responsible for generating the response for that request and this method is also responsible for generating responses to all HTTP methods ie. GET, POST etc.

Cleanup

The destruction phase of the JSP life cycle is when a JSP is being removed from use by a container. The jspDestroy() method is the JSP equivalent of the destroy method for servlets. Override jspDestroy when you need to perform any cleanup, such as releasing database connections or closing open files.
The jspDestroy() method has the following form:
public void jspDestroy() {
// Your cleanup code goes here
}
Enjoy Learning.

How JSP works internally

The following steps explain how JSP works inside the web server:

Client browser sends an HTTP request to the web server.
The web server recognizes that the HTTP request is for a JSP page and forwards it to a JSP engine. This is done by using the URL or JSP page which ends with .jsp instead of .html.
The JSP engine loads the JSP page from disk and converts it into servlet content. This conversion is very simple in which all template text is converted to println( ) statements and all JSP elements are converted to Java code that implements the corresponding dynamic behavior of the page.
The JSP engine compiles the servlet into an executable class and forwards the original request to a servlet engine.
A part of the web server called the servlet engine loads the Servlet class and executes it. During execution, the servlet produces an output in HTML format, which the servlet engine passes to the web server inside an HTTP response.
The web server forwards the HTTP response to your browser in terms of static HTML content.
Finally web browser handles the dynamically generated HTML page inside the HTTP response exactly as if it were a static page

Below image shows pictorial view of how JSP works

Upon getting client request, JSP engine checks whether a servlet for requested JSP file already exists and whether the modification date on the JSP is older than the servlet. If the JSP is older than its generated servlet, the JSP container assumes that the JSP hasn't changed and that the generated servlet still matches the JSP's contents.

Enjoy Learning.

Overview of JSP

Overview

JavaServer Pages (JSP) is a server-side programming technology that enables the creation of dynamic, platform-independent method for building Web-based applications. JSP have access to the entire family of Java APIs, including the JDBC API to access enterprise databases. JavaServer Pages (JSP) technology enables you to mix regular, static HTML with dynamically generated content.
JavaServer Pages (JSP) is a technology for developing web pages that support dynamic content which helps developers insert java code in HTML pages by making use of special JSP tags, most of which start with <% and end with %>.
A JavaServer Pages component is a type of Java servlet that is designed to fulfill the role of a user interface for a Java web application. Web developers write JSPs as text files that combine HTML or XHTML code, XML elements, and embedded JSP actions and commands.
Using JSP, you can collect input from users through web page forms, present records from a database or another source, and create web pages dynamically.
JSP tags can be used for a variety of purposes, such as retrieving information from a database or registering user preferences, accessing JavaBeans components, passing control between pages and sharing information between requests, pages etc.

Advantages of JSP

JSP offer several advantages in comparison with the CGI.

Performance is significantly better because JSP allows us to include Dynamic Elements in HTML Pages.
JSP are always compiled before they get processed by the server.
JSP are built on top of the Java Servlets API, hence like Servlets, JSP also has access to all Java and J2EE APIs, including JDBC, JNDI, EJB, JAXP etc.
JSP pages can be used in combination with servlets that handle the business logic, the model supported by Java servlet template engines.
It is easier to write and maintain the HTML. Your normal HTML (static code) is has many limitations like no extra backslashes, no double quotes, and no lurking Java syntax.
You can use standard Web-site development tools. We can make use of many tools like Eclipse, Macromedia Dreamweaver for developing JSP. Even HTML tools that know nothing about JSP can be used because they ignore the JSP tags.
You can divide up your development team. The Java programmers can work on the dynamic code. The Web developers can concentrate on the presentation layer. On large projects, this division is very important. Depending on the size of your team and the complexity of your project, you can enforce a weaker or stronger separation between the static HTML and the dynamic content.

Advantages of JSP over other technologies

Active Server Pages (ASP): The advantages of JSP are twofold. First, the dynamic part is written in Java, not Visual Basic or other MS specific language, so it is more powerful and easier to use. Second, it is portable to other operating systems and non-Microsoft Web servers.

Servlets: It is more convenient to work with regular HTML than to have plenty of Java Code with println statements that generate the HTML.

Server-Side Includes (SSI): SSI is really only intended for simple inclusions, not for "real" programs that use form data, make database connections, and the like.

JavaScript: JavaScript can generate HTML dynamically on the client but can hardly interact with the web server to perform complex tasks like database access and image processing etc.

Static HTML: Regular HTML, of course, cannot contain dynamic information.

Following diagram shows the position of JSP container and JSP files in a typical Web Application.

Enjoy Learning.

JSP Implicit Objects

JSP Implicit Objects are the Java objects that the JSP Container makes available to developers in each page and developer can call them directly without being explicitly declared. JSP Implicit Objects are also called pre-defined variables and managed by container.

Total 9 Implicit Objects are provided by JSP -

Object	Description
request	This is the HttpServletRequest object associated with the request.
response	This is the HttpServletResponse object associated with the response to the client.
out	This is the PrintWriter object used to send output to the client.
session	This is the HttpSession object associated with the request.
application	This is the ServletContext object associated with application context.
config	This is the ServletConfig object associated with the page.
pageContext	This encapsulates use of server-specific features like higher performance JspWriters.
page	This is simply a synonym for this, and is used to call the methods defined by the translated servlet class.
Exception	The Exception object allows the exception data to be accessed by designated JSP.

Request

The request object is an instance of a javax.servlet.http.HttpServletRequest object. Each time a client requests a page the JSP engine creates a new object to represent that request.
The request object provides methods to get HTTP header information including form data, cookies, HTTP methods etc.

Response

The response object is an instance of a javax.servlet.http.HttpServletResponse object. Server creates response object to represent the response to the client.
The response object also defines the interfaces that deal with creating new HTTP headers. Through this object the JSP programmer can add new cookies or date stamps, HTTP status codes etc.

Out

The out implicit object is an instance of a javax.servlet.jsp.JspWriter object and is used to send content in a response to the client.
The initial JspWriter object is instantiated differently depending on whether the page is buffered or not. Buffering can be easily turned off by using the buffered='false' attribute of the page directive.
The JspWriter object contains most of the same methods as the java.io.PrintWriter class. However, JspWriter has some additional methods designed to deal with buffering. Unlike the PrintWriter object, JspWriter throws IOExceptions.
Following are the important methods which we would use to write boolean char, int, double, object, String etc.

Method	Description
out.print(dataType dt)	Print a data type value
out.println(dataType dt)	Print a data type value then terminate the line with new line character.
out.flush()	Flush the stream.

Session

The session object is an instance of javax.servlet.http.HttpSession and behaves exactly the same way that session objects behave under Java Servlets.
The session object is used to track client session between client requests.

Application

The application object is direct wrapper around the ServletContext object for the generated Servlet and in reality an instance of a javax.servlet.ServletContext object.
This object is a representation of the JSP page through its entire lifecycle. This object is created when the JSP page is initialized and will be removed when the JSP page is removed by the jspDestroy() method.
By adding an attribute to application, you can ensure that all JSP files that make up your web application have access to it.

Config

The config object is an instantiation of javax.servlet.ServletConfig and is a direct wrapper around the ServletConfig object for the generated servlet.
This object allows the JSP programmer access to the Servlet or JSP engine initialization parameters such as the paths or file locations etc.
The following config method is the only one you might ever use, and its usage is very rare.
config.getServletName();
This returns the servlet name, which is the string contained in the <servlet-name> element defined in the WEB-INF\web.xml file

PageContext

The pageContext object is an instance of a javax.servlet.jsp.PageContext object. The pageContext object is used to represent the entire JSP page.
This object is intended as a means to access information about the page while avoiding most of the implementation details.
This object stores references to the request and response objects for each request. The application, config, session, and out objects are derived by accessing attributes of this object.
The pageContext object also contains information about the directives issued to the JSP page, including the buffering information, the errorPageURL, and page scope.
The PageContext class defines several fields, including PAGE_SCOPE, REQUEST_SCOPE, SESSION_SCOPE, and APPLICATION_SCOPE, which identify the four scopes. It also supports more than 40 methods, about half of which are inherited from the javax.servlet.jsp. JspContext class.
One of the important methods is removeAttribute, which accepts either one or two arguments. For example, pageContext.removeAttribute ("attrName") removes the attribute from all scopes, while the following code only removes it from the page scope:
pageContext.removeAttribute("attrName", PAGE_SCOPE);

Page

This object is an actual reference to the instance of the page. It can be thought of as an object that represents the entire JSP page.

Exception

The exception object is a wrapper containing the exception thrown from the previous page. It is typically used to generate an appropriate response to the error condition.

Enjoy Learning.

Thursday 28 June 2018

Technical Lead QA Questions asked in Sears Holdings

1. What is the best definition of a Class?
a) A provision for holding state and behaviour together.
b) Can only have state and behaviour at Class level also.
c) An entity that is formed with neat boundries clear responsibilities and remains cohesive.
d) A template for an object that encapsulates state(s) amd behaviour.

2. Which statements are true out of the following :-
S1: Static State have same value in all objects.
S2: Non Static can have same/different value in all the object.
S3: Non Static states and behaviour belongs to Class and not to Object.
a) S1,S2
b) S1,S2
c) S1,S3
d) S1,S2,S3

3. What is true about Object :-
S1: Contains all Static Stuff
S2: Gets created with initialized values of Non-Static/Static states for fields.
S3: Example of Encapsulation
a) S1,S2,S3
b) S2,S3
c) S1,S2
d) S1,S3

4.Same Behaviour but different implementation is: -
a. Polymorphism
b. Abstraction
c. Encapsulation
d. Inheritance

5.Which of the following assumption is true: -
S1: Static Global Variable
S2: Non Static Parameters
S3: Static Local Variables
S4: Non Static Method
a) S1,S3
b) S2,S3
c) S1,S2 and S4
d) All of the above

6.Out of the following which one is non-primitive data type: -
a) Int
b) String
c) Float
d) Boolean

7.Can we access Non Static stuff directly inside Static Method?
a) Yes
b) No

8.Can we access everything (Static, Non Static Stuff) directly inside Non Static Method :-
a) No
b) Yes

9. Which term is not an equivalent term of Non Static Method: -
a. Instance Method
b. Dynamic Method
c. Class Method
d. Object Method

10. Can we access local variables indirectly: -
a. Yes
b. No
c. Yes and No

11. If I am not initializing local variable but I haven’t used it anywhere then what will happen in this case :-
a. Gives Compilation Error
b. Default Initialization will happen
c. Exception will come
d. No error will come until we use the local variable anywhere

12. Which Statement(s) is/are False
S1: Constructor cannot be abstract
S2: Constructor can be Static
S3: It can have any return type
S4: It returns a value
a) All of the above
b) S1,S4
c) S2,S3
d) S2,S3,S4

13. Identify the output of the following code snippet: -
package this_keyword;
public class UsageOfThis {
int i=1;
public void method1(UsageOfThis ref) {
System.out.println(ref.i);
System.out.println(i);
System.out.println(this.i);
}
public void method2(){
System.out.println(i);
UsageOfThis ref2 = new UsageOfThis();
this.i=3;
i=6;
System.out.println(this.i);
System.out.println(ref2.i);
method1(this);
}
public static void main (String[] args){
UsageOfThis ref1 = new UsageOfThis();
ref1.method2();
System.out.println(ref1.i);
}
}

14. Identify the Output of the following code snippet :-
package rough;
public class DIL{
{
int i=9;
}
int i=0;
{
int i =8;
}
public static void main (String[] args){
DIL ref = new DIL ();
System.out.println(ref.i);
}
}

15. Identify the Output of the following code snippet :-
package rough;
public class DIL{
{
i=9;
}
int i=0;
{
i =8;
}
public static void main (String[] args){
DIL ref = new DIL ();
System.out.println(ref.i);
}
}

16. If you are reviewing a code written to automate, how would you go about doing this activity?

17. If you are writing code in Java, please explain the UMl artifacts you will want to create, and why.

18. If there is a need to run your tests across environments (DEV,QA, etc.) explain in detail, the steps you will take to ensure that one ca run tests across environments with ease.

19. If you are using recursion to solve any problem, what are the guidelines you will follow?

20. Automate the following scenario :
a. Open a website www.xyz.com
b. Click on a button whose attribute “id” is dynamic in nature (e.g., id=”abc123”,”abc3531” and so on…where text “abc” is static)
c. On clicking above button a new browser window opens up.
d. Go to new browser window and select the 11th dropdown option fron drop down menu(id=drpdwn) where the DropDown is inside a fram (id=frameid1)
e. On selecting the above drop down option a confirmation message “Option Saved successfully” shows up(outside the frame) – Validate this message (Your Test Case will Pass/Fail on this validation and you are not allowed to use any conditional statements like if – else to validate)
f. Close the Parent Window.

21. What do you expect as output: -
SELECT id, YEAR(BillingDate) AS BillingYear FROM invoices WHERE BillingYear >=2010;

22. Tell the output: -
Class A {
public static void main(String args[]){
String str1 =”ABCD”;
String str2 = new String(“ABCD”);
if (str1.equals(str2)){
System.out.println (“Hello1”);
}
if (str1==str2){
System.out.println (“Hello2”);
}
if (str1.equalsIgnoreCase(str2)){
System.out.println (“Hello3”);
}
}
}

23. Write a short note on using XML,JSON – can you enumerate principal benefits of using any of these?

24. Use regular expression to change “dd-MON-YYYY” to “MON/YYYY/DD”.

25. Write a program to count the number of occurrences of an integer in an array.
Ex:- int[] arr= {2,4,6,2,8,9,4,4}
O/P :- 2 occurred 2 times; 4 occurred 3 times and so on.

Enjoy Interview.

Senior QA Questions asked in Sears Holdings

• What is the best definition of a Class?
a) A provision for holding state and behaviour together.
b) Can only have state and behaviour at Class level also.
c) An entity that is formed with neat boundries clear responsibilities and remains cohesive.
d) A template for an object that encapsulates state(s) amd behaviour.

• Which statements are true out of the following :-
S1: Static State have same value in all objects.
S2: Non Static can have same/different value in all the object.
S3: Non Static states and behaviour belongs to Class and not to Object.
a) S1
b) S1,S2
c) S1,S3
d) S1,S2,S3

• What is true about Object :-
S1: Contains all Static Stuff
S2: Gets created with initialized values of Non-Static/Static states for fields.
S3: Example of Encapsulation
a) S1,S2,S3
b) S2,S3
c) S1,S2
d) S1,S3

• Same Behaviour but different implementation is: -
a. Polymorphism
b. Abstraction
c. Encapsulation
d. Inheritance

• Which of the following assumption is true: -
S1: Static Global Variable
S2: Non Static Parameters
S3: Static Local Variables
S4: Non Static Method
a) S1,S3
b) S2,S3
c) S1,S2 and S4
d) All of the above

• Out of the following which one is non-primitive data type: -
e. Int
f. String
g. Float
h. Boolean

• Can we access Non Static stuff directly inside Static Method?
i. Yes
j. No

• Can we access everything (Static, Non Static Stuff) directly inside Non Static Method :-
k. Yes
l. No

• Which term is not an equivalent term of Non Static Method: -
m. Instance Method
n. Dynamic Method
o. Class Method
p. Object Method

• Can we access local variables indirectly: -
q. Yes
r. No
s. Yes and No

• If I am not initializing local variable but I haven’t used it anywhere then what will happen in this case :-
t. Gives Compilation Error
u. Default Initialization will happen
v. Exception will come
w. No error will come until we use the local variable anywhere

• Which Statement(s) is/are False
S1: Constructor cannot be abstract
S2: Constructor can be Static
S3: It can have any return type
S4: It returns a value
a) All of the above
b) S1,S4
c) S2,S3
d) S2,S3,S4

• If there is no constructor written, the primitive member variables are initialized ?
x. True
y. False

• Default constructor that compiler automatically adds has an empty body?
z. True
aa. False

• What will be the O/P of the following code snippet: -
public class Example2 {
public void method1(){
Map <Integer,String> map = new HashMap <Integer,String>();
map.put(1,”One”);
map.put(2,”Two”);
map.put(3,”Three”);
method2(map);
System.out.println(map.get(3));
}
private void method2(Map<Integer,String> map1){
Map1.put3(3,”Three Hundred”);
}
public static void main(String args[]){
new Example2().method1();
}
}

• Name the techniques you use to write black box test cases?

• If you are testing an application and you find a “bug”, what would you compile and report?

• List negative tests for payment module/function in an e-commerce website.

• If there is a database column whose datatype is Number(11,3) what does it mean to you ? What would be the tests (with specific numbers) that are significantly important, as you test this data type?

• Identify tags, attribute names, attribute values, elements, nodes in the following xml: -
<bookstore>
<book category=”Children’s literature”>
<title lang=”en”>The Jungle Book</title>
<author>Rudyard Kipling</author>
<year>1894</year>
<price>939</price>
</book>
</bookstore>

• How do you execute a test case with multiple sets of data input in TestNG or JUnit or any tool that you have use?

• To a method “addTen”, a string (String s=”2016”) is given as input. The method adds 10 to the number and returns an integer in this case it returns an integer 2026. Write the method.

• Consider a Drop Down menu (whose “name” attribute is “drpdwn”). Write a code snippet to select the 11th item in this dropdown.

• Write a Selenium code for the following test case to be rum on “Google Chrome”: -
bb. Open a website www.abc.com
cc. Click on a link whose text is “Click Me” (That will open a new browser pop up that is not an alert box)
dd. Go to pop up and verify the title name (Expected Title is “Title 2” and the test case will pass/fail based on this validation)
ee. Close “Parent” window only.

Enjoy Interview.