1st Assignments

The Logical Operators Are The Operators Which Are Applied On Both The
Ends Or Both The Operants. So The Basic Logical Operator Supported In Java
Programming Language Are And Or And Not. The And Operator Is Used To
Perform Logical Operation On Two Operands And It Will Result In A Boolean
Result. So To Become A True Boolean Result And Should Be Having Both The
Operands As True And In Order To Result A True Value Either One Of The
Operands Should Be True And When It Comes To Not, Not Is Just A Simple
Logical Operator Which Negates The Existing Value That Means If The Value
Is True Then After The Not Operation The Value Will Be Converted Into False
Now Let Us See One Basic Example To Understand Logical Operators In A
Much Better Way You Can See The Previous Example Is The Best Fit To
Understand Logical Operators You Can See The Value Here Was False Since A
Is Greater Than B So This Value Will Result In A False And This Value Will
Result In False So False And False Will Result In False Now Moving Ahead We
Shall Understand The Next Type Of Operators Which Are The Ternary
Operators. The Ternary Operator Is Simple But Highly Powerful Operator Used
In In Java Programming Language This Particular Ternary Operator Will
Reduce The Code Length To One Line To Understand This In A Much Better
Way Let Us Execute A Sample Program Here You Can See That We Have Two
Different Values Which Are A And B. A Has Two And B Has Five So The Ternary
Operator Is This Particular Statement Here We Have Also Allocated A New
Variable Which Is Of Integer Type Which Is Minimum So Minimum Is Equals To
A Less Than B If A Is Less Than B Then Minimum Is A And Else B Is Equals To
Minimum So This Particular Operation As Minimum Here A Is Compared If A Is
Truly Less Than B Then A Will Be Printed Into Minimum Else We Will Be
Printed Into Minimum And Finally We Shall Print The Value Which Is Stored
Into Minimum Now Let's Execute This And See The Output. You Can See That
The Value Of A Which Is Two Is Been Printed Here After Executing The Ternary
Operator Present Underline Number Seven. Now Let Us Move Ahead And
Understand The Next Type Of Operators Which Are The Assignment
Operators. The Assignment Operators Used In Java Programming Language
Are Simply Used To Allocate The Resultant Memory Into The Variable Which Is
Located In The Left Side Of The Operand The Basic Assignment Operators
Used In Java Programming Language Are Equals Two And Double Equals Two.
Two Understand Assignment Operators In A Much Better Way Let Us Execute
A Sample Java Program So This Particular Program Is Based On Assignment
Operations Here We Have Two Different Values Which Are A And B. A Is
Equals To Ten And B Is Equals To Twenty Now What We Are Basically Doing
Here Is Using The Assignment Operator And Adding Value Four To The Value
Ten And Decrementing Value Four These A Value Twenty. This Particular
Operator Used Here This Assignment Operator. Now The Result Will Be A Is
Equal To Fourteen And B Is Equals To Sixteen Now Let Us Execute This
Program And See If The Output Will Be Correct Or Not. You Can See The
Output Is As Expected With This Let Us Move Ahead And Understand The
Control Statements In Java. A Control Statement In Java Is A Statement That
Determines Whether The Other Statement Will Be Executed Or Not In Simple
Terms It Controls The Flow Of A Particular Program In Java Now Let Us See
The Control Statements Which Are Present In Java So The Control Statements
Supported In Java Are If Else Loop While Loop Do While Loop For Loop And
Switch Case So These Are The Basic Control Statements That Each And Every
Programmer Must Be Known With Now Let Us Understand Each And Every
One Of These Controls Statements And Also Execute A Basic Program To
Understand Them In A Much Better Way. Firstly We Should Deal With The If
Statement Or If Control Statement In This Statement If The Conditions
Specified Is True The If Block Will Be Executed Otherwise The Else Block Will
Be Executed We Shall Execute A Sample Program To Understand The If Else
Statement In A Much Better Way. So This Particular Program Is Based On If
Else Control Statement Here We Have The Input A Is Equal To Fifteen The First
If Condition Will Be In Case If A Is Greater Than Twenty And The First Printf
Statement Should Be Executed Else The Other Printed Statement Should Be
Executed Now Let Us Execute This Program And See The Output. Since We
Know Fifteen Is Less Than Twenty We Should Be Expecting The Second Set Of
Statements To Be Executed Which Is A Is Less Than Ten And Hello World You
Can See The Message Has Been Successfully Printed Here Followed By This
Let Us Move Ahead And Understand The Next Type Of Control Statements
Which Are Supported In Java That Is None Other Than The File Loop Known As
The Most Common Loop The While Loop Evaluates The Certain Condition If
The Condition Is True Then This Code Is Executed The Process Is Continued
Until This Specific Condition Turns Out To Be False The Condition To Be
Specified In While Loop Must Be A Polian Expression An Error With
Regenerated If The Type Is Used Is Not An Int.
 Twost Assignments

By Two Now This Particular Set Of Loop Will Be Executed Until The Value Of I
Is Less Than Or Equal To Fifteen Once After This Condition Becomes True The
Loop Will Be Terminated Let Us Try To Execute This Program And See The
Output. You Can See The Values Five Seven Nine Eleven Thirteen And Fifteen
Are Printed Successfully Months After The Value Of I Reached To Fifteen The
True Got Dominated And It Exited The Loop. Now Followed By This Let Us
Understand The Next Type Of Loop Which Is The Do While Loop The Do While
Loop Is Completely Similar To The While Loop The Only Difference Is That The
Condition Of The Do While Loop Is Evaluated After The Execution Of The Loop
Body This Guarantees That The Loop Is Executed At Least Once Now Let Us
Try To Execute A Sample Program To Understand Do While Loop In A Much
Better Way You Can See That This Particular Example Is Based On Do While
Loop Here We Have A Variable I Which Stores The Value Twenty So Once After
The Value Has Been Declared We Have The Do Value So Inside The Do Value
We Are Supposed To Print The Value Of I The Value Of I Will Be Incremented
By One Every Single Time The Loop Is Executed Now The Loop Body Of Do By
Loop Is Finished So The Condition Is Placed At The End Of Do Value Which
Says The I Value Should Be Less Than Or Equal To Twenty Until Then This
Particular Loop Is Valid Now The Only Suspense Between Do While Look And
While Loop Is The Do While Loop Will Be Executed At Least For Once Without
Checking The Condition Because The Condition Is Placed After The Do Loop
Body. Now Let Us Try To Execute This NCD Output . You Can See That The
While Loop Is Been Successfully Executed The Value Twenty Is Printed Only
For Once Because The Value Of I Which We Declared Was Twenty And It Is
True According To The Condition So The Control Got Terminated Let Us Move
Ahead And Understand The Next Type Of Loop Or Just The For Loop The For
Loop In Java Is Used To Iterate And Evaluate A Code Multiple Times But The
Number Of Iterations Is Known By The User It Is Recommended To Use The
For Loop To Understand The For Loop In A Much Better Way Let Us Try To
Execute One Basic Example Based On For Loop So This Particular Example Is
Based On For Loop Here We Have The Value Of I As One And The Condition Is
I Is Less Than Or Equal To Ten And After That A Post Increment So In This
Particular Statement We Will Be Printing The Value Of I Ten Times Until The
For Loop Is True The Three Basic Parts Of A For Loop Are Declaration
Condition And Increment Or Decrement So This Particular First Block Which Is
I Is = To One Is The Declaration Part And After That I Is Less Than Or Equal To
Ten Is The Condition Part And Lastly I + + Which Is The Increment As The
Last Part Now Let Us Try To Execute This Program And See The Output . You
Can See That The Program Has Been Successfully Executed And The Value Of
I Is Printed For Ten Times Which Is One Two Three Four Five Six Seven Eight
And Nine Ten Now Followed By This Let Us Understand The Next Type Of Loop
Which Is This Switch Case. A Switch Statement In Java Is Used To Execute A
Single Statement From Multiple Conditions This Switch Case Statement Can
Be Used With Short Bite End Long Enum Types Et Cetera Certain Points Must
Be Noted By Using This Switch Statement Which Are One Or Any Number Of
Case Values Can Be Specified For A Switch Expression Case Values That Are
Duplicate Or Not Permissible A Compile Time Error Is Generated By The
Compiler If Unique Values Are Not Used Next The Case Value Must Be A Little
Or A Constant Variables Are Not Permissible The Last Condition Is Usage Of
Break Statement Is Made To Terminate The Statement Sequence It Is Optional
To Use The Statement If The Statement Is Not Specified Then Next Case Is
Automatically Executed Now Let Us Try To Execute A Sample Program To
Understand Switch Case In A Much Better Way You Can See That This
Particular Program Is Based On Switch Statement This Switch Condition Is
Instrument Now Here The Condition Is That We're Supposed To Select The
Instrument Number Four Which Happens To Be Loop Now We Have A Various
Set Of Instrument Present In R Case Which Are Piano Drums Guitar Flute Italy
Violin And Lastly The Default Statement Which Is Invalid Let Us Try To
Execute This Program And See The Output Since We Have Provided Our
Selection To Be 4 Which Happens To Be Fluid The Output Should Be Directly
Generated As

3rd Assignment

The Last Difference Is The Array Is Consume More Memory Because Hardly The Array
Memory Which You Allocate Is Being Reused. But In Terms Of Linked List, The Memory
Which You Use Can Be Dumped Back Into The Heap And It Is Readily Available For Reuse. So
Array Is Consume More Memory And Linkless Consume Less Memory. Next Understand What
Is The Hash Map In Java? Hash Map Is A Part Of Java's Collection Since Java Version 1.Two. It
Provides The Basic Implementation Of Map Interface In Java. It Stores The Data In Key Value
Pairs. To Access The Value, One Must Know Its Key. Hash Map Is Known As Hash Map
Because It Uses A Technique Called Hashing. So What Is Hashing? It Is The Technique Of
Converting A Large String To A Small String That Represents The Same String. A Shorter
Value Helps In Indexing And Faster Searches. Hash Set Also Uses Hash Map Internal. It
Internally Uses A Linked List To Store Key Value Pairs. So The Important Features Of Hash
Map Are It Is A Part Of Java Util Package. It Extends An Abstract Class That Is Abstract Map
Which Also Provides An Incomplete Implementation Of Map Interface. Hash Map Also
Implements Cloneable And Serializable Interface. It Does Not Allow To Click It Keys, But It
Allows Duplicate Values. That Means A Single Key Cannot Contain More Than One Value, But
More Than One Key Can Contain A Single Value. Hash Map Allows Nulkey Also, But Only
Once And Multiple Null Values. And This Class Makes No Guarantees As To The Order Of The
Map. In Particular, It Does Not Guarantee That The Order Will Remain Constant Over Time. It
Is Roughly Similar To Hash Table But This Unsynchronized. So These Are The Various
Features That Makes It The Popularly Used To The Structure. Next Talking About The Internal
Structure Of Hash Map, It Contains An Array Of Node And Node Is Represented As A Class
Which Contains 4 Faiths That The Int Hash K Key V Value And Node Next. It Can Be Seen
That Node Is Containing A Reference Of Its Own Object. So That Is The Reason That Is Called
A Link List. So Very Simple It Comprise Of A Node Which Comprises Of Key And Value And
It Has The Impasse And Node Is Having The Reference Of The Next Variable As Well. So This
Is All About The Internal Structure Of Hash Map. Not Talking About The Performance Of Hash
Map. It Mainly Depends On Two Parameters, That Is Initial Capacity And The Load Factor. So
Capacity Is The Number Of Buckets Where The Initial Capacity Is The Capacity Of The Hash
Map Instance When It Is Created. The Lord Factor Is A Measure That, When Rehashing, Should
Be Done. And Rehashing Is A Process Of Increasing The Capacity. In Hash Map Capacity Is
Multiplied By Two. And Lower Factor Is Also A Measure That What Fraction Of The Hash Map
Is Allowed To Fill Before Rehashing. When The Number Of Fairies In The Hash Map Increases,
The Product Of Current Capacity And The Load Factor Is Also Increased. That Is It Implies
Rehashing Is Done. If The Initial Capacity Is Kept Higher Than Three Hashing Will Never Be
Done. But By Keeping It Higher It Increases The Time Complexity Of Filtration. So It Should
Be Chosen Very Cleverly To Increase The Performance. The Expected Number Of Values
Should Be Taken Into Account To Set The Initial Capacity. Most Generally Preferred Load
Factor Value Is .75 Which Provides A Good Deal Between The Time And Space Cost And The
Lower Factors Value Varies Between Zero And One. Based On These Two Factors That The
Initial Capacity And A Load Factor Performance Of A Hash Map Is Measured. Now Let's More
Into The Next Section And Understand What Is The Synchronized Hash Map. Ask At This
Already Told That Hash Map Is Unsynchronized, That Is Multiple Threads Can Access It
Simultaneously. If Multiple Threads Access This Class Simultaneously And At Least One
Thread Manipulates It Structurally. Then It Is Necessary To Make It Synchronized Externally.
At This Done By Synchronizing Some Object Which Encapsulates The Map. If No Such Object
Exists Then It Can Be Wrapped Around Collection Synchronized Map To Make Hash Map
Synchronize And Avoid Accidental Unsynchronized Access. So You Can See That I Have Used
Collections Dot Synchronized Map And Created A New Hash Map. So By Using This A Map M
Is Synchronized. Iterators Of This Class Are Fail Fast If Any Structure Modification Is Done
After The Creation Of Iterator In Any Way Except Through The Iterators Remove Method. In A
Failure Of Iterator, It Will Throw Concurrent Modification Exception. So This Is How You Can
Make A Map Synchronized. Now Let's See Some Of The Constructors That Are Widely Being
Used. Hash Map Provides 4 Constructors And Access Modifiers Of Each One Of Them Is
Public. First One Hash Map. It Is A Default Constructor Which Creates An Instance Of A Hash
Map With Initial Capacity 16 And Lower Factor .75. Next Hash Map Initial Capacity. This Also
Creates A Hash Map Instance Which Specified Initial Capacity And A Load Factor .75. Next,
Hash Map With Int Initial Capacity And Float Load Factor. It Creates A Hash Map And Stands
With Specified Initial Capacity And Specified Load Factor. Next One That Is The Last
Constructor. Hash Map Which Has Arguments Of Type Map. It Creates Instance Of Hash Map,
Same Mappings As A Specified Map. So Now Let's Write A Small Program And Understand
How Does The Hash Map Work. So I Have Created A Class Called Hash Map And Inside That I
Have A Main Method. And You Can See I'm Using Hash Map And I'm Passing The Parameters
Like String And Integer And I'm Mapping It With The Object Of A New Hash Map. So First
When I Print The Map It Should Say This Map Is Empty Because Nothing Is There And The
Map Right? So Then I'm Using The Put Method To Insert The Elements Into The Mark That Is
ABC 10, MNO 30 And X Version Two0. Then Then I Print This, It Will Say The Size Of The
Map That Is 3. Then Next I Will Check Whether A Map Contains A Key Called ABC. So This Is
The Keys And This Is The Value Of The Respective Key, Right? So When I Check If It Has A
Key Called ABC, Then I'm Using A Mac Docket To Display The Value Of ABC. So The Value
For Key ABC Will Be Whatever Is Present In This, Right? Then Again I'm Clear In The Map
And Again Printing The Map.

4rd Assignment

We Will See Which Tools Are Used In Devos Approach And Also How These
Tools Operate In Each Of The Devops Stages. I Will Talk About A Use Case
Where I Will Show How Eddie Vega Is Following Devops Approach To Deploy A
New Homepage On Select Audience. This New Home Page Is Having Some
Personalized Features For A Particular Set Of Audience At The End. I Will Be
Implementing This Using Different Tools In Devops. So Stay With Me Till The
End Of This Session. Guys. It's Going To Be Very Interesting. This Is How They
Develop Stages Look Like In The Real World. They Spend Few Seconds Guys
On This Slide. Just By Looking You Can Understand Different Stages And
Develops And How They Are Connected. You Can See Developers Are Writing
Their Code And After They Commit Their Code, It's Going To Version Control
Stage. So This Is The First Stage In Devops. In This Stage You Can Manage
The Code Sitten By Your Developers. The Next Stage Is Continuous
Integration. So What Does Continuous Integration Mean? Rather Than
Waiting For All Their Developers To Commit Their Code And Then Building
And Testing It. In Continuous Integration Approach, When Any Developer
Comes To Code, That Code Is Merged With The Main Branch. Then You Can
Use Jenkins To Create A Build. After That You Can Test Your Code In A
Virtualized Environment. So This Saves A Lot Of Time In Moving The Code
From Dev Environment To Test Environment. We Need Not Wait For All The
Developers To Commit. Even Though You Are Able To Do Continuous
Integration, It Is Of No Use If You're Not Testing Continuously. So The Next
Stage Is Continuous Testing In This Stage. You Can Automate Your Test By
Writing A Selenium Script And Then Run It Through Jenkins In A Virtualized
Environment. If The Test Fails, We Stop Here And Send Back The Issues To
The Developers. If The Test Passes, We Move Ahead And Deploy It. Now In
Continuous Deployment Stage, We Have Two Parts, Configuration
Management And Container Valuation. Let's Talk About Configuration
Management First. There Are Five Hours Up And Running And They Have
Same Environment, Libraries, Tools On Them. They Would Be Many Of You
From Older Background. Where In Past We Used To Have Shell Script To Do
This Job, Now If I Need To Have Exact Same Configuration Across Hundreds
Of Servers, Using Shell Script Will Be Obviously Pretty Much Complex. Hence
We Need A Tool Which Can Automate This Job For Me. Property Is The Most
Popular Tool For Configuration Management. The Second Part Of Continuous
Deployment Is Containerization. In This Stage Add Mentioned Before, You Can
Create A Test Environment Where You Can Run Your Application And Test It.
This Stage Is Mostly Used For Testing Purpose. It Gives Virtualized
Environment Where I Can Run My Selenium Script To Test My Application.
90% Of Organizations Are Using Containerization. Being Testing Stage, Only
10% Of Organization Are Using It On Production. In Late Two015 Docker 1.9
Came Which Was Table Two On Production As Well. For Example, If You Need
To Run Few Applications On Prod For Shorter Duration, You Can Easily Create
A Container On Prod And Run Through The Application In That Container And
When You Don't Need Those Application Anymore You Can Destroy The
Container. You Can Refer To The Video Mentioned Here To Understand More
On Containerization And Virtualization. Now That You Have Deployed Your
Application, You Need To Monitor It To See If The Application Is Performing As
Desired And The Environment Is Also Stable. This Is Where Continuous
Monitoring Comes Into The Picture. By Monitoring The Application, You Can
Quickly Determine When A Service Is Unavailable And Understand The
Underlying Causes. And Then You Can Report Back All The Issues To The
Developers. So Now You Says One Of The Most Popular Tool Used In
Continuous Monitoring. So This Is How All Their Develop Stages Are
Connected. Developers Are Coding Over Here, They Are Pushed All Their
Code On Toolkit Where Version Control Happens And You Manage All The
Codes Here. Then You Can Make A Build And Run It Through Jenkins. After
Building It, You Can Run Your Automated Test Scripts In Selenium Using
Jenkins. Once The Test Passes You Can Deploy It On Prod Where You Can Use
Property For Configuration Management And Deploy On Thousands Of
Servers. And Finally You Can Do Monitoring On Your Application Using Radios.
So You Get A Lot Of Benefits For Using Devops Approach. First One Is The 1st.
Deployment We Were Able To Move The Code Very Fastly From Dev
Environment To Test Environment. We Need Not Wait For All The Developers
To Commit Their Code. You Can Easily Scale To Thousands Of Servers. Puppet
Can Automatically Do Configuration Management To Even Thousands Of
Servers. And Also Once You Deploy Your Application Onto The Product, If
Something Goes Wrong You Can Roll Back To The Previous Table Version So
It's. Be Reliable. Let Us Discuss The Use Case. Now Think About A Scenario
Where We Have Launched A New Homepage With Some Personalized
Features. So Before We Make It Available To All The Users, We Want To Roll It
To Select Audience To Test And Ensure That Everything Is Working Fine Before
Wider Deployment. This Approach Is Called Dark Launching. This Term Was
Coined By Facebook. You Can Refer This Video To Know More About Dark
Launching. Let's Assume That We Are Using It For US Audience Only. So We
Deploy This Home Page Only On US Servers. Now That Another Difference Is
We Want To Migrate It To K PHP Three. Our Previous Version Of Home Page Is
On Cake PHP Two. Total Solution We Can Have To Deploy Our New Homepage
On US Servers. Now If We Deploy This New Homepage On Each Server
Manually It Will Be Time Taking. And Also It Is Not Scalable. A Shell Script Can
Do The Job But It's Complex To Run It On Multiple Servers And Any Change
Made To Script In The Future Will Lead To More Complexity. Hence We Need A
Configuration Management Tool Which Can Do This Job Automatically And
Also Scale To Thousands Of Servers Without Any Hiccups. Now That You Guys
Have Understood The Use Case, We Are Good To Go. Let's Get Started. But
Before I Begin. The Practical Let Me Show You The Environments I'm Using.
So I'm Using Three Machines In This Demo. I'm Using Different Operating
Systems To Give You A Feel Of Working With Different Environments. On The
1st Machine I'm Having Sent OS Where My Jenkins And Puppet Master Are
Running. Second Machine Is My Test Machine. This Machine Is Having Kuntu
Where I Create My Test Environment Using Docker And Run. Any Application
In A Docker Container, A Pocket Agent Is Also Running On This Machine. I Will
Run A Test Case For Login As Well By Running This Selenium Script Through
Jenkins. My Third Machine Is My Production Machine. This Is Also Having
Ubuntu Operating System. A Puppet Agent Is Running On This Machine And
This Is Where I Deploy My Application Finally. So Let's Begin With The Demo.
So Let's Start The Practical Now. So The First Thing Is My Project Is Already
There On The Github. Whatever Developers Made The Project, They Pushed
On Github. So Using Jenkins I Can Pull It Onto Machine One. I'll Just Create A
Simple Jenkins Job Which Will Pull This Project Which Is There On Github And
On Machine One You Can See My Puppet Master Is Running And Machine Two,
Machine 3 Already Puppet Agent Is Running. So Guys, If You Don't Have
These Git, Jenkins, Puppet, All These Configured, No Need To Worry. Just
Follow The Video Which Is Mentioned Over Here And You Can Set All These
Up On Your System As Well. OK, So Let's Go Ahead And Get The Project Using
Jenkins Onto Machine One. So My Project Is There On Github. I Just Create A
Simple Job In Jenkins To Pull The Project From Github. So I Will Go To My
Machine. Hey So My Jenkins Is Already There. I Have A Project Over Here. Let
Me Just Show You This Project. All You Need To Do Is Create A Project. You Can
Give A Name And Just Go To Source Code Management Kit Where You Can
Give This URL. Now From Where I'm Getting This URL Right Let Me Go To My
Browser. So This Is Where My Github Project Is There. Can You See
Erica_Home? This Is My Homepage Application Which I'm Going To Deploy
Today. Now If You Click On Clone Or Download, You Can Get A Key Over Here.
Can You See Use An SSH Key And Passwords From Account? So This Is The
SSH Key And Passphrase For My Account. So This Is What Is There On
Machine. So Repository URL, You Need To Give This One. And My Username,
Password Is Already Configured Over Here. If I Click Just On Add, You Can See
All You Need To Do Is You Need To Configure Your Username And Password,
Right? So That Is There. And My Branch By Default It's Master. That's All You
Need To Do. Just Give Your Repository URL And Credential, That's All.
Favorite. OK Now If I Click On Build Now. You Can See One Build Will Start
Over Here. Let Me Click On This Build Console Output. OK So The Build Has
Completed. It Has Succeeded. Now If I Do A Simple LS Command Let Me Go
To Home Eureka Dot Jenkins. Workspace And My Project Was Demo New. So If
I Do LS, Can You See? And You Can't Just Go Home. So This Is My Application
Which I Have Pulled Onto Machine One. Let's Go Back To The Second Step. So
After This, What I Need To Do Is My Puppet Master Is Running On Machine
One And My Puppet Agent Is Already There On Machine Two. So Now What
Puppet Agent Does Is It Periodically Talks. The Puppet Master In Real World
Scenario, It Periodically Talks With Puppet Master And Whatever
Configuration Is There On Puppet Master, It Pulls It Up On Machine Two. Also
Wherever Puppet Agent Is Running, They Pull The Configuration For Puppet
Master. For Our Session, I'll Be Just Running A Simple Command Which Will
Be Pulling The Configuration Right. So What I'll Do Is My Puppet. Already
Configured, I'll Just Show You What All Puppet Files Are There, What All
Configurations I Have Set Up On My Puppet Master. So It Will Be Sending The
Application Which I Have Just Now Pulled On Machine 1-Two, Machine Two, I'll
Just Show You The Configuration How It Happened. And Once The Application
Goes On Machine Two, I'll Be Running That Application Inside A Docker
Container. So Let Me Go To. Machine One And. I Will Go To EDC Open By Do
LS. I Have Just Created A Module. That's Copy.

5rd Assignment

Now I'm Using A Method Called Print By Passing The Arguments For Map
Means It Should Contain The Map Of Same Mappings. So If It Is Empty Then
Print Map Is Empty Else Return The Elements And That Is The Key Value Pairs
Present In The Map. So Let's Run And Check The Output. So First What It
Said, It Said Map Is Empty Because I'm Printing The Map Without Entering
Anything In That. So It Will Go To The Print Method And Check Whether The
Map Is Empty Or Not. Yes It Is Empty So It Will Retrieve The Result. So Next
This Statement Got Executed And It's Telling The Size Of The Map History
Because It Has The Key Value For Three Different Categories. Again It Will
Print The Map. So This Will Again Go To The Function Definition And Print This
Statement Because Now The Map Is Not Empty. So There Is A Function Call
Over Here And Now Size Of The Map Is Map . Size. What Is The Size? Three
So It Is Displaying The Size Of The Map As Three. And It's Printing All These
Elements Now Value For Key ABC Is Ten. So That's What I'm Checking Over
Here. That Is, Get The Key For ABC And Print Its Value. So If I Do It Again, Like
You Know, MNO. Again, Change It Over Here As Well, And Here As Well. OK,
So It Will Print The Value Will Be Thirty. So Finally After Clearing The Map
Again It's Telling Map Is Empty. Now Let's Run And Check The Output. It's
MNO. You Can See That The Value For The Key MNO Is Thirty Right? I Hope
You Understood This. So This Is How You Can Configure Your Hash Map And
Map It Accordingly. So Now Talking About The Complexity Of Hash Map, It
Provides A Constant Time Complexity For Basic Operations That Is Get And
Put If Hash Function Is Properly Written And It Disperses The Elements
Properly Among The Buckets. Iteration Over Hashmap Depends On The
Capacity Of Hashmap And The Number Of Key Value Pairs. Basically It Is
Directly Proportional To The Capacity Plus Size And Capacity Is The Number
Of Buckets In The Hash Map. So It Is Not A Good Idea To Keep A Higher
Number Of Buckets And Hashmap Initially. So This Is All About The Time
Complexity. Now Let's Have A Look At The Various Methods That Are Widely
Being Used In A Hash Map. First Void Clear. This Is Used To Remove All The
Mappings From A Map. Next Boolean Contains Key That Is Parameter Will Be
Object Key. This Is Used To Return True If For A Specified Key Mapping Is
Present In That Map. And Again Boolean Contains Value Of Object Value. This
Is Yours Return True If One Or More Key Is Mapped To A Specified Value. Next
Method Is Object Clone. This Is Used To Return A Shallow Copy Of The Object
Of The Mentioned Hash Map. Next Bullen Is Empty. Use To Check Whether
The Map Is Empty. Returns True If It Is Empty. Next Object Get Object Key.
This Is Used To Retrieve Or Fetch The Value Map By A Particular Key. Set Key
Set. This Is Used To Return A Set Views Of The Key. In Size You Should Return
The Size Of The Map. Next Object Put Parameters Will Be Key And Value. This
Is Used To Return A Particular Mapping Of Key Value Pair Into A Map. Next,
Put All Of Map M. This Is Used To Copy All Of The Elements From One Map To
Other. Next Object Remove Object Key. This Is Used To Remove The Values
For Any Particular Key In The Map And The Last One Is Collection Values
Versus Used To Return A Collection View Of The Values In The Hash Map. So
These Are The Various Methods That Are Widely Being Used In The Hash
Map. Let's Understand What Is Generics In Java. Generics Is A Term That
Denotes A Set Of Language Features That Are Related To The Definition And
The Use Of Generic Types And Methods. Java Generic Methods Differ From
Regular Data Types And Methods. So Before Generic We Use The Collections
To Store Any Type Of Objects. It Can Be Either A Generic Or Non Generic
Object. Now Generics Forced The Java Programmer To Store A Specific Types
Of Objects. So Basically This Is All About What Is Generics. Now Let's Move
Further And See Why Do You Need Java Generics. If You Look At The Java
Collections Framework Then You Will Observe That Most Of The Classes Take
Parameter Or Argument Of Type Object. So Basically What Happens In This
Form? They Can Take Any Java Type As Argument And Return The Same
Object Or Argument. It Can Be Either A Homogeneous Or Heterogeneous
That Is Not Of A Similar Type. So Sometimes In The Java Application, The
Data Type Of The Input Is Not Fixed. The Input Can Be An Integer, A Float, Or
A Java String. In Order To Assign The Input To The Variable Of The Right Data
Type, Prior Checks Had To Be Conducted. In The Traditional Approach, After
Taking The Input, The Data Type Of The Input Was Checked And Then It Was
Assigned To The Variable Of The Right Data Type. When This Logic Was Used,
The Length Of The Code And Execution Time Was Increased. So To Avoid This,
Generics Were Introduced. So On Using Generics, The Parameters In The
Code Is Checked At Compile Time Automatically. And It Sets The Data Type
By Default. So This Is Where You Need The Concept Of Generics In Java As
The Execution Time And The Time That You Invest In Writing The Code Will
Also Be Decreased. So Now That You Know What Is Generics In Java And Why
Do You Need It, Let's Move Further And See Some Of The Types Of Generics.
So Basically There Are Four Types. First Generic Type Class And You Have
Interface, Method And Constructor. First Let's Understand What Is Generic
Type Class. A Class Is Set To Be Generic If It Declares One Or More Types Of
Variables. So These Variable Types Are Known As The Parameters Of The Java
Class. Let's Understand This With The Help Of An Example. So Here You Can
See I Have Created The Class With One Property X And The Type Of The
Property Is Object, Correct? So What Happens Once You Initialize The Class
With The Certain Type, The Class Should Be Used. With That Particular Type
Only. For Example, If You Want One Instance Of A Class To Hold The Value Of
Type String, Then Programmer Should Set And Get Only String Type. Since I
Have Declared The Property Type To Object, There Is No Way To Enforce This
Restriction. A Programmer Can Set Any Object And Expect. Any Return Value
From The Get Method Since All Java Types Are Subtypes Of Object Class. So
It's Very Simple Right? So Here I'm Creating A Method For Set And Get And
I'm Using The This Keyword For Reference. And Then When I Return The
Value Of The X It Can Be Any Type But All The Java Types Are Subtypes Of
Object Class. So I Can Set A Property For Integer And I Can Return String
Anything It Can Be. So This Is How It Works. The Next Type Is Generic Type
Interface And Interface In Java Refers To The Abstract Data Types. They Allow
Java Collections To Be Manipulated Independently From The Details Of The
Representation. Also The Former Hierarchy In Object Oriented Programming
Languages. So Let's Take An Example And Understand This. So Here I Have
Created A Interface For Generic And I'm Doing Two Operations For T One And
T Two. So For Two What I'm Doing I'm Performing The Execution. I'm Passing
Two Variables That Are T One And X And Next What I'm Doing I'm Performing
A Reverse Execution Of Whatever I Have Performed In The Upper Statement.
So When I Create A Class For Generic And Implement The Interface.
Whatever I Perform The Execution Will Be Reversed In The Next Execution.
Suppose Say While Performing The Execution, I'm Passing A String Variable
And That Can Be Easily Converted To An Integer Variable When I'm Reversing
The Execution. So Basically All That Matters Is The Type Of The Object And
There Is No Way That I Have To Enforce Restriction Or Anything Like That. It
Can Be A String, Integer Or Double, Float, Anything. So I Hope You Was Able
To Understand How Generics Can Be Applied To Interfaces. Now Let's See
What's Next. The Next Type Is Generic Type Method. So Generic Methods Are
Much Similar To Generic Classes, But They Differ From Each Other In Only
One Aspect, That Is, The Scope Or Type Of Information Is Available Inside The
Method Only. Generic Methods Introduce Their Own Type Parameters. So
Let's Take An Example And Understand This. So In This Case What Happens If
You Pass A List Of String To Search In The Method It Will Work Fine But If You
Try To Find Number In The List Of First String It Will Give Compile Time Error.
Here's Right Because See First I'm Using Advanced For Loop. I'm Trying To
Check The Element Present In The List. If The List Isn't String Then It Will
Match Because Always List Is A String. Like List Can Be A String, It Can't Be A
Integer.

6th Assignment

What Is An Interface? In Simple Words And Interface Can Be Defined As

Anything Which Shares A Boundary Between Two Components. In Case Of
Computers It Separates Two Systems And Access A Boundary Which Helps In
Data Exchange. Now What Is A Java Interface? A Java Interface Can Be
Defined As An Abstract Type Which Stores The Methods And Helps Other
Classes To Implement The Behavior Of The Methods Which An Interface
Actually Stores. Now You Might Get A Question. We Have Interface For That.
Yeah, Absolutely. With This We Begin Our Next Question, Why We Need
Interface? We All Know That Java Supports Inheritance. But When It Comes To
Multiple Inheritance, Java Cannot Support It. It Ends Up Facing Ambiguity
Between Two Parent Classes And Fails To Provide The Required Result. This
Particular Problem Is Called As Diamond Problem. Here As You Can See There
Is A Super Class And This Super Class Is Being Inherited By Two Classes
Called As Class A And Class B. Now We Are Trying To Inherit The Properties Of
Class A And Class B Into A New Class Which Is Class C Which Practically
Seems Impossible In Terms Of Java. Now The Question Would Be, Is It
Seriously Impossible To Do It? That's When The Interface Comes To The
Picture. Using Interface We Can Achieve Multiple Inheritance. Here We Are
Inheriting One Class And Implementing The Behavior Of Another Class.
Confused. Let Me Explain With The Little Example. Let Us Consider An
Airplane Which Requires Both The Properties Of Carrying Huge Cargo And
Passengers. Let Us Assume We Have Two Planes. One Is Capable Only To
Carry Passengers And The Other One Is Capable Only To Carry Cargo. Now
We Need To Carry Both Passengers And Cargo In One Single Plane, Which
Seems To Be Impossible On The Basis Of How The Java Works As It Feels It
Cannot Access The Properties Of Two Different Pairing Classes At The Same
Time. But You Can Make It Possible By Making Java Feel That It Is Inheriting
One Play And Implementing The Methods Present In The Other One. It Is Like
Building A Commercial Plane Which Takes Both The Passengers And Cargo.
Luggage Interface Is Like Making A Bigger Plane Which Could Do Both The
Tasks Without Interfering With The Components Of One Another. Insert Just
Borrowing The Methods Which Are Present In The Interface Class. Now Let Us
Get Practical. First Let Us Understand What Was The Problem In Multiple
Inheritance. Here I Have Defined The First Class Class A And Then The Next
Class Which Is Class B And Finally The Class C Here I'm Trying To Inherit The
Properties Of Class A And Class B Together In The Class C By Using Exchange
Keyword. As You Can See, The Editor Is Throwing An Error Which Says That It
Is Not Possible To Inherit The Properties Of Both The Classes. Now Let Us Find
The Solution For This. The Solution Is None Other Than Using Any Interface.
Here In This Solution I Am Creating An Interface. I'm Having The Same
Messages Which I Had In My Earlier Example. Both The Messages Present In
Class A And Class B And Similarly I Have Also Defined The Interface Which
Has Both The Methods Hello And Welcome. Now Let Us Run This Program And
See. How Does It Work? As You Can See, It Is Accessing Both The Methods
And Printing The Message Present In Both The Classes Class A And Class B.
Now Let Us Try A Different Example. In This Example, I Am Declaring Four
Methods, Addition, Subtraction, Multiplication And Division. Now Let Us Enter
Into A Class. Here I'll Be Trying To Access All The Four Methods And Print The
Output. Now Let Us Try To Run This Program And See How The Output
Appears. As You Can See. The Program Has Been Successfully Compiled And
Now It Is Asking For Two Integer Values To Perform The First Operation Which
Is Addition. The Output Has Been Successfully Generated And Now It Is
Asking For Two More Integer Values To Perform Subtraction. The Difference Is
Been Displayed Now It Is Asking For Two More Integer Values For Performing
The Multiplication Operation. The Output Is Clear. Now Let Us Perform Our
Final Operation Which Is Division. As You Can See, We Have Our Result Here.
Now Let Us Understand The Interface Nesting. As You Can See I Have Nested
An Interface By The Name Inner Interface Inside Another Interface Which Is
The Outer Interface. And Then I'm Trying To Generate A Fibonacci Series
Using The Method Which Is Present In The Inner Interface Which Is None
Other Than The Inner Method. Using This Method We Will Be Generating The
Fibonacci Series. Let's Try To Run The Program And See The Output. As You
Can See, We Have A Fibonacci Serie Printed Here And This Process Was Being
Executed From The Nested Inner Interface Method. Now Let Us Try To See An
Example For Nesting By Nesting An Interface Inside A Class. Here I Have
Listed An Interface Called Edureka Interface Inside A Public Class Which Is
Edureka Class And Inside The Edureka Interface I Have A Method Called
Nested Method Using Which I'll Be Performing A String Reverse Operation.
Let Us Execute This Program. As You Can See The Stringer Have Provided Is
Edureka And After The Operation You Can See The String Is Been Successfully
Reversed. Now Let Us Have One Short Quick Revision About How To Declare
An Interface. So This Is A Syntax For Declaring An Interface Where You Will
Be Using An Interface Keyword Followed By The Name Of Your Interface. And
Inside The Interface You Can Declare Your Methods. By Default All The
Methods Which You Declare In Interface Are Considered To Be Public. With
This Let Us Find Out The Few Differences Between Class And An Interface.
The First Difference Is Multiple Inheritance. Interface Was Designed To
Provide Multiple Inheritance Where On The Other Hand Classes Cannot. The
Next Difference Is Data Members. Interface Does Not Have Data Members.
All It Includes Is Methods Which Decrease The Probability Of Confusion
During The Implementation Process. On The Other Hand, Classes Include
Data Members Which Mean To Say That The User Must Be Careful While
Using The Data Members To Avoid Ambiguity. The Next Difference Is
Constructors Interface Does Not Have Constructors While On The Other Hand
Classes Take Up The Advantage By Including Them Which Will Help Them To
Set The Values To The Members Of An Object. And The Next One Is Complete
And Incomplete Members. Interfaces Comprise Of Only Methods Which Make
Them Have Only The Signature Methods In Them. While On The Other Hand
Classes Include Both Data Members Which Are Also Called As Abstract
Members As Well As Methods Which Are Known As Signature Members. The
Next One Is Access Modifiers. Interfaces Does Not Have Access Modifiers. By
Default Interfaces Take Up Public As Their Access Modifiers, Whereas Classes
Provide Private Access Modifiers Which Are Not Available In The Interface.
The Next One Is Static Members. Interface Cannot Have Any Static Members,
Whereas Class Has All Its Members As Static. With This, Let Us Get Into The
Major Advantages And Disadvantages Of Interface. First, Let Us Begin With
Advantages. We Can Achieve Multiple Inheritance In Java. We Can Easily
Break Up Complexity And Enable Clear Dependency Between The Objects.
We Can Achieve Loosely Covered Applications Through An Interface. Don't.
Just Be On The Bright Side, Interfaces Have Some Disadvantages As Well.
Java Interfaces Make The Application Slower When Compared To The
Competitors Like Python Which Support Multiple Inheritance. The Next One Is
Once An Interface Is Included In An Application, It Might Be Used Once In A
While, Or It Might End Up Being Used Multiple Times At A Larger Scale. With
This, Let Us Discuss About The Key Points About Java Interfaces. The First
One Is Can We Instantiate An Interface? Well, We Cannot Create An Object Of
An Interface, Hence We Cannot Provide Instances In An Interface. The Next
One Is Abstraction. The Major Key Advantage Of Interface Is Abstraction,
Because None Of The Methods Declared In An Interface Have A Body. The
Next Key Point Is Implementing An Interface. The Keyword Implement Is Used
In A Class To Implement The Methods Of An Interface. The Method In An
Interface Must Be Provided With An Access Modifier As Public By Default The
Methods Declared In An Interface Are Also Considered As Public. Class Must
Implement All The Methods Declared In An Interface. Or Else It Must Be
Declared In An Abstract Class. Let Us See An Example About Implementing
An Interface. Here I Have Defined An Interface And Declared Two Methods
Into The Interface, Method One And Method Two. The First Method Is Used To
Find Out A Square Root Of The Given Number And The Second Method Is
Used To Print A Message. Now Let Us Try To Execute This Program. As You Can
See, It Is Asking For An Input. Now Let Us Provide A Number To Find Out Its
Square Root. As You Can See, The Square Root Of The Given Number Is Four.
Now Let Us Try To Execute A Different Example Where We'll Be Implementing
The Methods From Two Different Interfaces. As You Can See This Is My First
Interface And Here My First Method Is To Find Out Whether A Given Number Is
An Armstrong Number Or Not. And Later Let Us See A Second Interface
Where I Have Declared A Method To Find Out If The Given Number Is Prime
Number Or Not. Now Let Us Try To Execute This Example And See If The
Program Can Implement Both The Methods From Two Different Interfaces Or
Not.

7th Assignment

Now, The Main Topic File Is Over Here. If I Give Manifest Site Dot P P, This Is
My Main Manifest File. So All I'm Doing Is I'm Just Importing This Module
Which I Have Created And I'm Calling For This My File. Let's Go Ahead On
One Machine To And Execute It. So As I Said Before, I'll Just Run A Simple
Command. Let Me Go Inside Root So Normally Property Agent Periodically
Talks With Master And Puts All The Configuration. Just For This Demo I'm
Using This Command. Puppet Agent- T It Will Pull All The Configuration From
Puppet Master. OK So My Job Is Almost Finished. So We Were Sending The
Application On Machine Two In Home Edureka App One Directory. Let's Go
Here Inside App On Directory. Can You See My Application Is Present On
Machine Two Now Right? So My Puppet Job Other Threshold. Now The Next
Thing What I Need To Do Is I Need To Run This Application Which Has Come
To Machine Two Inside A Docker Container. So I Need To Build A Docker Image
And I Need To Run This Command To Start A Docker Container. Now Let's See
How To Do That. I Will Go Back To My Machine Two. So Can You See A Docker
File Over Here So. You Can Get Lot Of Dockery Images On Hub.Docker.Com
Which You Can Use It Like For Me I'm Using A K PHP Application So I Can Use
A K PHP Docker Image Directly. They Give A Docker File Also So Everything
Will Get Installed Inside A Docker Container. All Their Commands Are There
This Docker File Using This Docker File You Can Build Your Own Docker Image
As Well. So That's What I Have Done. So My Docker File Looks Like This Is
Almost As The Same As K PHP Docker File. I'm Just Moving My Edureka Home
Inside Bad WWW HTML Where My Apache Is Running Right And I'm Moving
All The Files Which Are There In Edureka Home Inside This Far And At The End
I Am Running A Simple Script Run.SH Which Is Running My Application. So
Now Let Me Just Go Ahead And Show You How To Build A Docker Image. So I'll
Give A Command Docker Build - T Whatever Docker Image Name You Want To
Have, You Can Give It Over Here. Let Me Give It A Edureka Underscore New
Three And Dot. Once I Press Enter, It Will Start To Build A Docker Image. Can
You See It Is Building A Docker Image And All The Commands Which Were
There One By One, Each Command In The Docker File Will Get Executed. So
Let's Wait. And We Will Have A Docker Image At The End. Can You See? One
By One Is Executing All The Commands Which Was There In Docker File. OK,
So It Was Successfully Created A Docker Image. Now I Can Check It By Using
The Command Docker Images. If I Give It Can You See It Has Created A New
Docker Image Edureka Underscore New Three Twelve's Seconds Ago. Just
Now We Have Created A New Docker Image. He Can Have A Docker
Container Using This Image Where Our Application Will Run. OK Let Me Go
Back To My Slide. So To Run A Container All You Need To Do Is Run A Docker
Image. Now Using Docker Run And Giving The Port Number OK And Giving
The Application Part And My Image Name. Just Now The Image Which I
Created Using This Docker Run, It Will Create A Container. OK Inside The
Docker Image It Will Create A Docker Container Where Our Application Will
Run. Let Me Go To Machine Two. So Now If I Give Command Docker PS
Already One Container Is Up And Running Where My Application Is Running. I
Used The Image Edureka New It Is Very Similar Image To Edureka Underscore
New Three Let Me Use This Container Itself. All You Need To Do Is Use. Docker
Run Command And The Image ID, The Same Container Will Get Created. OK,
So Now If I Need To Go Inside This Container, Let Me Just Give The Command.
Docker Exact. So Docker Exact Is The Command Jenny To Give. OK That's It -
I T And I Will Use This Container ID OK And Been Dash. Anything Earlier I Was
In Route At The Ubuntu. Now I'm Inside The Container Root At The Rate. This
Container Right LS All I Wanted To Show Us. All My Application Files Are
Already There Inside Bar Www.Stml Where My Apache Is Running. Now You
Can See This Sport. My Application Is Already Up And Running On This Zero.
Zero. Zero. Zero I Have Configured This For Www.Edurekahyphendev.Co. So
Now If I Go To Browser And Go To This URL Www.Edurekahyphendev.Co I Can
See My Application Up And Running Over There. So Let's Go To My Browser
Now. So Let Me Just Go And Open This URL. Which Is Running On Port
Number Nine Thousand Six. I Have Configured 0.0.0.04 Edureka - Dev.Co
Yeah, Can You See My Homepage Is There Now My Edureka Homepage. So I
Have Successfully Deployed Edureka Homepage On My Desk Machine. Right
Now Let's Run A Simple Test Case. So That Will Be Our Next Job. Now Once
Your Application Is Running Inside A Docker Containers, You Can Run Your
Selenium Script On It OK Using Jenkins. So What We Will Do Is We Will
Prepare And Build A Selenium Project. I Will Just Quickly Show You My
Selenium Projects. It's A Java Project And I Will Be Exporting It As A Ant Build
And Then I Will Be Running A Selenium Test Inside Jenkins. Let Me Show You
How To Do That. Now, If I Go Over Here, It's A Simple Java Project.
Selenium_Test Dot Java, Right? I Will Right Click On This Project And I'm Just
Checking It For A Simple Login. OK, That's All I'm Doing Over Here. I Will
Export I Will Go To General And Click On And Build Files. Collect Your Project
And I Want This JE Unit To Be In My Project Path. I Will Give It As Home
Edureka Work Space And My Project Name Is Selenium, This Is Where My JE
Unit Direct Will Be There. So All I Need Is This Build.Xml File. Let Me Just Click
On Finish. Now If You Come Down Can You See It Has Created A Build XML File
And It Will Give Me A Target Name. Can You See Target Name Selenium_Test.
So This Will Be Running Using Jenkins. Let's See How To Do That. Let Me Go
Back. My Jenkins Is Already Running. I Will Create A New Project. I Will Create
Selenium Project. Click On Freestyle Project And Click On OK. Scroll Down
And Go To Built. And Click On Invoke And Add A Built Step. Invoke Add. Now
My Target Name Was Selenium_Yes, Just Now We Saw That. OK And They Call
Advance And Just Give The Part Of Build File. So Let Me Go To My Project And
Click On Properties Here Of Our Builder XML File. It Will Give Me The Part
Where Builder XML File Is Residing Control C. Go Back Here And Past It And
Apply Save. Now, Let's Build It. Now What You Will Be Doing It It Will
Automatically Open Our Mozilla Browser Where It Will Open My Edureka
Home Page And It Will Just For A Simple Login Automatically. I Won't Be Doing
Anything So It Has Opened My Homepage. Went To Sign In, Check For A
Simple Login Right? Now If I Go On This Build Which Was There And Click On
Console Output. Can You See The Built Was Successful? So I Have
Successfully Ran My Selenium Script Using Jenkins. And Now Let's Go Back
Here. What's The Next Step? No, Once My Desk Has Successfully Passed, I
Can Destroy My Container, Right? I Can Destroy My Image Itself, The
Complete Docker Image. I Don't Need It Anymore. So Let's Go Back To
Machine Two. So Now That My Test Was Successful, I Can Destroy My Docker
Image Now, Which Will Eventually Destroy The Docker Container As Well. So
How To Do That? Let Me Go Out Of This Container. So We Were Having. These
Many Docker Images Right? So If I Click If I Do Docker Images, Can You See
All These Images Were There Not Now Let's Say I Want To Destroy This Image
And Edureka_New Three Which We Created Just Now. OK, So All We Need To
Do Is Docker RMI And Use This Image ID OK. Can You See Deleted My Docker
Image. Now If I Give The Command Again Docker Images You Won't Find That
Image Edureka_New Three. Let's Go. OK So Now After Destroying This Docker
Image The Next Part Is We Can Go Ahead And Deploy Our Application On
Machine Three. So Let's Go Ahead And Do That. OK, So This Is What We Were
Supposed To Do. We Have Already Done It. You Can Destroy Your Container
Using This Docker Stop Container ID, Docker RM Container ID. If You
Completely Want To Remove Your Docker Image Itself, You Can Use This
Command Docker RMI And The Image ID. OK, Now That The Test Has Passed
And We Have Destroyed The Container. Finally, You Can Deploy Your
Application On Machine Three. Now Let Me Go To My Machine Three. So My
Machine Three Is Over Here. Right So My Puppet Agent Is Was Running On
My Machine Three Also. So I Need To Pull All The Configuration On This
Machine As Well. I Will Do Puppet Agent I Forty. So It Will Pull All The
Configuration. Basically It Will Pull My Application From Machine One To
Machine Three. OK, Now It Has Pulled It Over Here. All I Need To Do Is. Move
It To Where Www.Html Right And For The Prod Machine, My URL Is Edureka-
Us Dot Co. Now That It Has Come To My Machine Three Also And I Have
Placed In Bad WWW STML Where My Apache Is Running. So It Should Be
Deployed Over Here Also. So Now Let's See Whether It's Working Over Here.
Yes, Can You See It Has Been Deployed On My Machine Three As Well If I Just
Click On Simple Sign In, Let Me Just Check For Sign In As Well. See You Are
Able To Sign In As Well. So I Have Successfully Deployed My Edureka
Homepage On My Prod Machine As Well. So We Have Come To An End Of This
Session Guys. So Let Me Summarize This Complete Session. So We Have
Seen What All The Stages Are There In DevOps Life Cycle, Version Control,
Continuous Integration. Continuous Testing, Continuous Deployment,
Continuous Monitoring With All Stages Are There In DevOps Life Cycle And
There Are Hundreds Of Tools Which You Can Go Ahead And Use To Follow This
DevOps Approach. But The Selection Of Tool Depends On Your Requirement
And The Organization Which You Are Working For. OK, So Let Me Summarize
The Use Case As Well The Edureka Use Case Which We Just Now Saw So My
Project Was There On GitHub OK And Using Jenkins I Pulled My Project On
Machine One. Then Using Puppet I Sent This Application To Machine 2 Where
Using Docker Container I Ran My Application And I Ran A Simple Selenium
Script Using Jenkins And I Tested My Application. Once The Test Has Passed I
Destroyed My Docker Container And Finally I Deployed My Application Onto
Machine Three OK.

8th Assignment

Well, You Can Call It As A Master Plan For Testing. Next Question Is, Is It True
That You Can Actually Go Ahead And Do System Testing At Any Stage?
System Testing. All The Components Of Software Are Tested As A Whole In
Order To Make Sure That Overall Product Meets The Requirements Specified.
So No, System Testing Cannot Be Performed At Any Stage. It Can Only Start If
All The Units Or Modules Are In Place And Are Working Individually Properly.
And Another Thing Is That System Testing Actually Happens Before You
Perform User Acceptance Testing. Next Question Is What Are Certain Best
Practices That You Should Follow When Writing Test Cases? When You're
Performing Testing On A Large Scale, You Have Like Thousands Of
Requirements To Consider, And If You Go Ahead And Write Your Test Cases
Randomly, It Will Become Difficult For You To Track Later On. For That Very
Reason, You Have Some Practices That You Can Go Ahead And Follow, And
It'll Make You Much More Easier To Keep Track Of Your Test Cases. So First Of
All, Prioritize Which Test Case To Write Based On The Project Timeline And
The Risk Factor Of Your Application. Always Remember The Eighty Twenty
Rule. So To Achieve Best Coverage Twenty % Of Your Test Should Cover
Eighty % Of Your Application. That's Eighty Twenty Rule. So Don't Try To Test
All The Cases In One Attempt, Instead Improvise Them As You Progress. List
Down On Your Test Cases And Classify Them And Separate Them Based On
Your Business Scenarios And Different Functionality. Make Sure Your Test
Cases Are Modular And Your Test Case Steps Are As Granular As Possible.
Another Thing Is That Right Your Test Cases In Such A Way That Others Can
Easily Understand Them And Modify Them If Required. Always Keep End
Users Requirement In Back Of Your Mind Because Ultimately The Software
Product That You're Testing Or Designing Is For The Test End Users. Well,
Always Remember Using A Test Management Tool To Manage Stable Release
Cycle. Monitor Your Test Cases Regularly, Right Unique Test Cases And
Remove Irrelevant And Duplicate Ones. Going On To Our Next Question, Why
Is That Boundary Value Analysis Provides Very Good Test Cases. So The
Reason Why Boundary Value Analysis Provides Good Test Cases Is That A
Greater Number Of Errors Actually Occur At Boundaries Rather Than In The
Center Of The Input Domain For Any Test. So Basically In Boundary Value
Analysis. Test Cases Are Designed To Include Values And Boundaries, And
That's Why Boundary Value Analysis Provides Very Good Test Cases. So If The
Input Is Within The Boundary Value, It's Considered Positive Testing, And If
Your Input Is Outside Of Your Boundary Value, It's Considered Negative
Testing. So When I Say Boundary Value Analysis, It Includes Different Values
Like Maximum, Minimum, Inside Or Outside Edge, Typical Values Or Error
Values. Next Question That We Have Is Why Is It Impossible To Test A
Program Thoroughly Or In Other Terms Hundred % Bug Free? Cause It's
Impossible To Build A Software Product Which Is 100% Bug Free. You Can Just
Minimize The Error Flaws Or Failures Or Faults In Your Computer Program Or
System Which Causes It To Produce An Unexpected Result, But It's Impossible
To Make It Hundred % Error Free. Well, Here Are Some Two Principal Reasons
That Make It Impossible To Test A Program In Time. First Of All, Software
Specifications And Requirements Can Be Subjective. And It Can Lead To
Different Interpretations. Secondly, A Software Program Might Require Too
Many Inputs, Too Many Outputs, And Too Many Path Combinations To Test.
While These Reasons Make It Impossible To Test A Program Entirely. So The
Last Question That We Have Is Can Automation Testing Replace Manual
Testing? Automation Testing Isn't A Replacement For Manual Testing. No
Matter How Good Automation Tests Are, You Cannot Actually Go Ahead And
Automate Everything Right. Manual Display A Very Important Role In
Software Development, And They Come In Handy Whenever You Have A Case
By Auto Apply Automation. So Automation And Manual Testing Each Have
Their Own Strength And Weaknesses. In Simple Terms Manual Testing Helps
You To Understand The Entire Program Or Problem And Explore The
Functionality Of Your Feature And Applications From Users Perspective Or In
Other Words With More Flexibility. On Other Hand, Automated Testing Helps
Save Time In Long Run By Using Lot Of Tools And Techniques And Scripts. So
Like I Said, Both Of Them Have Their Pros And Cons.

9th Assignment
So You Can See Here It Has Two Ends At This Front End And Back End. That Is
The Front End And The Rear End. So If You Insert An Element It Goes To The
Front And That Can Be. Removed But In Case Of Stack It Is Last In First Out.
In Case Of Q It Is First And First Out. It Supports 2 Most Fundamentals Such
As Enqueue And Dequeue. Enqueue Means You Have To Insert The Element
At East That Is At The Rate Of The Queue And Dequeue Means Remove And
Return The Element From The Front Of The Queue. So Whatever Element You
Insert At The Rear End Will Go To Front. As Soon As You Insert It More Right
So Simple That Can Be Taken Off From The QN. So Queues Are Used In The
Asynchronous Transfer Of Data Between Two Processes That The CPU
Scheduling. This Scheduling And Other Situations Where Resources Are
Shared Among The Multiple Users And Served On First Come First Serve
Basis. So These Are Some Of The Situations Where Q Can Be Used. OK, So
Now Let's Take An Example And Understand How It Works. So This Is Very
Simple. I Have Created A Class Called Queue And I'm Creating A String Of
Queue And Assigning It To A Link List. So What I'm Doing Is I'm Using Q Add.
And I'm Adding All The Four Elements And Then Displaying The Elements
Present In The Queue. So When I Say Queue Dot Remove Of Three It Will
Display The Elements Present In The Queue And The Queue Size And Says
Whether It Contains The Element True Or Not. If Yes It Displays That. Let's
Run And Check The Output. So First When I Printed This. It Displays The Size
And Let Me Tell You One Thing This Is The Inbuilt Function. So That Is The
Reason When I'm Using Add. It Is Being. Add It Automatically. So Then What I
Did I Removed The Element 3. See Here I Can Remove Any Element, It's Not
That The Element Which Is There At The Last Or The Element At The At The
Top Or Nothing Like That. You Can Just Remove The Element From Any
Corner. And Then When I Remove The Element And I Print The Queue It Says
Only The Remaining Elements That Is 1-2 And Four. Next Two Sizes Q Dot
Size That Is Three. And Then Whether Does It Contain The Element 2 In The
Queue? Yes, True If I Say Element 3 In The Queue. It Should Say False
Because I've Popped It Out Right? So Let's See What It Says. It Says True
Because. Initially In The Queue It Was Present, So If I Now Say Element 5.
Then Run. So When I Say Q Dot Contains 5. It Should Say False Because It's
Not There In The List, Right? See It's Telling False. So This Is How You Can
Perform The Operations On The Queue. The Next Data Structure Is Linked
List. A Linked List Is A Linear Data Structure With The Collection Of Multiple
Nodes Where Each Element Stores Its Own Data And A Pointer To The
Location Of The Next Element. The Last Link In The Link List Points To Null,
Indicating The End Of The Chain Element In The Linked List Is Called A Node.
The First Node Is The Head And The Last Node Is A Tail. So There Are Three
Types Of Linked List. On A Singly Linked List That Is Unidirectional Where It
Contains Only The Information Of The Next Node. So When It Comes To
Doubly Linked Lists And Contains The Information Of The Next Node, Also
The Pointer To A Previous Node. And When It Comes To Circular Linked List,
Head Points To A Tail And The Last Node Points To The First Element Of The
First. Note That Is The Last Element Of The Last Node Points To The First. Off
The First Note, So If I Have To Tell An Example. So Imagine A Linked List Like
A Chain Of Paper Clips And They're Linked Together. You Can Easily Add
Another Paper Clip To The Top Or Bottom. It's Even Quick To Insert One In The
Middle. All You Have To Do Is You Have To Just Disconnect The Chain At The
Middle At The New Paper Clip, Then Reconnect The Other Half. A Link List Is A
Similar Way Of Doing All These Operations. Let's Take A Small Example And
Understand This In A Better Way. So I Have Created A Class Called Linklist
Example And Node Head Is Ahead Of The List. And I Have Created A Class
Called Static Node. The Inner Classes Made Static So That Main Can Access
It. That Is The Main Method Can Access It. So I Have The Data And The Next
Node And The Constructor For The Node Is Int Because Data Is Equal To D
And Next Should Be Assigned To Null. Now The Next Step Is To Insert A New
Node. So For That What I'm Doing I'm Creating A Static Method For Linked
List Example And I'm Inserting Linked List Example List And Int Data And I
Have To Create A New Node With A Given Data. So What I'm Doing I'm
Creating A New Node With The Data And Assigning The Next Node To Null
Because That Is Mandatory. So If The Link List Is Empty Then Make The New
Node As Head. So If Link List Is Empty That Is If List Dot Head Is Equal To Null
Then Make The New Node As Help That This New Node Is Equal To Hell Head
Else Traverse Till The Last. Note That Is Node Last Is Equal To List Dot Head
And Then Insert The New Node. Again Insert The New Note At The Last Note.
And Finally You Have To Return The List By Hit OK Now. This Is A Method To
Print The Link List So Current Node Is Equal To List Dot Head And The Link
List Contains The Elements That Is Being Present In The Current Node And
The List That Is Already Being Inserted. So When I Have To Travel So The Link
List, I'll Check Whether Current Node Is Not Equal To Null. If It Is Not Equal To
Null Then Print The Data At The Current Node Using The Statement. What
Else? Go To The Next. In The Main Method I'm Creating An Object Of A New
Linked List And I've Inserting The Values Into The List In Sequence. Then
Finally I'm Printing The List. OK, So Now Let's Run And Check The Output. So
See. The Elements Are Being Inserted In The Sequential Order. So This Is How
It Works. So This Was All About The Linear Data Structures. Now Moving
Further We Have Hierarchical Data Structures Which Comprise Of Binary
Tree, Binary Heap And Hash Map As Well. So Binary Tree Is A Hierarchical Tree
Data Structure In Which Each Node Has At Most Two Children Which Are
Referred To As Left. And The Right Side. Each Binary Tree Has A Group Of
Nodes That The Root Node, Left Subtree And The Right Subtree. The Root
Node Is The Topmost Node And Often Referred To As Main Node Because All
The Other Nodes Can Be Reached From The Root And Left Subtree. And The
Right Subtree Is Also A Binary Tree And Binary Tree Can Be. Traversed In Two
Ways At The 10th 1st Traversal That Is In Inorder, Preorder And Postorder And
Breadth First Traversal That Is Level Order Traversal And The Complexity Is
Big O Of North And The Maximum Number Of Nodes At Level L Is 2 Raised To
The Power L -, 1 And Binary Search Applications. Include It Can Be Used In
Many Search Applications Where Data Is Constantly Entering And Leaving.
Also As A Workflow For Compositing Digital Images, For Visual Effects, Used
In Almost Every High Bandwidth Router, For Storing Router Tables, Also Used
In Wireless Networking And Memory Allocation. Also Used In Compression
Algorithms And Many More. So This Is All About The Binary Tree, Not Talking
About The Heap. It's A Complete Binary Tree Which Answers To The Heap
Property. In Simple Terms, It Is A Variation Of A Binary Tree With The
Properties Like. A Tree Is Set To Be Complete If All Its Levels Except The
Possibly The Deepest Are Complete. The Property Of The Binary Tree Makes It
Suitable To Be Stored In An Array. It Follows His Property That There's A
Binary Heap That's Either A Min Heap Or Max Heap. Min Heap Is For Every
Node In The Heap. Nodes Value Is Lesser Than Or Equals To Value Of The
Children.

10th Assignment

Let's Go Ahead. With The Next One. Next Question That We Have. 9th Delhi
Is At A Distance Of 250 Kilometer From Chandigarh. A Sets Out From
Chandigarh At A Speed Of 18 Meter Per Hour And B Sets Out In The Same
Time From Delhi At A Speed Of 45 Format Per Hour. When Will They Meet
Each Other? A One Hour 2 Hours. See 3RD Four. Let's Check Delhi And
Chandigarh 250 Kilometer Distance. Has Been Given To Us. Delhi,
Chandigarh. The Distance Is Given As 250 Kilometer. I'm Saying You That Is
That's All From Chandigarh At Speed Of 80 Kilometers Per Hour. I Speed Is 83
Sets Out From Delhi At A Speed Of. And We Said So From Delhi At The Speed
Of 45 Kilometer Per Hour. This Is What Has Been Given. Both Are
Approaching Towards Each Other Separation. We Know If We Evaluate
Velocity Of A With Respect To B, This Will Be Velocity Of A Minus Velocity Of B
Vectorially. Let Me Put This Sign Complete. We Last Year We Can Take This
Direction As Positive. So Let Me Take. Left Hand Side As Positive So
Automatically Right Hand Side Will Be Negative So Minus VB Will Be Actually
-45. So This Will Come Out To Be 125 Kilometer Per Hour. Now If We Stop, We
Here Only A To Catch Up To 50 Kilometer So That He Meets B. The Time Taken
Will Be We Are Doing Relatively. Time Taken Will Be Distance That Is South
Divided By Velocity Of A With Respect To B That Is 250 Divided By We Are
Having 125. That Will Give You 2R As The Required Result. So Easily We Can
Solve This. So Two Arguably Required Answer. So Option B Is The Right Result
And You Need Examination, You Need To Be Very Fast And Need To Be
Accurate So That You Can Score Maximum Marks. So That's Why I'm Doing It
Early. I'm Doing It Instantly So That You Can Also Learn How To Solve Such
Questions. Easily And Accurately. Next One. We Have. 10th 1-2 Trains, 121
Meter And 99 Meter In Length Are Running In Opposite Directions With
Velocities Of 40 Kilometer Per Hour And 32 Kilometer Per Hour. In What Time
They Will Completely Cross Each Other At 10 Seconds, 11 Seconds C 12
Seconds Read 13 Seconds Let's Check Two Trains. The Running Opposite To
Each Other. So If I Show You The Two Trains, Ohh No One Train Here And The
Other Train Here. One Is Of Length 121 Meter, The Other Is Of Length 99
Meter. Now See Here. If I Stop This Train, If I Let This Train To Overcome This,
It Will Travel Its Entire Length Of 121 Meter. This Train And It Has To Also
Cover Its Own Length That Is 99 Meter. Sort To Cross Each Other. Total
Distance Will Be 121 + 99. Total. Distance Comes Out To Be. 1/21. Plus 99.
That Will Come Out To Be 200 And. 20m This Will Be The Total Distance
Traveled. Now You Stop One Train, Both Are Crossing Each Other. So If I Say
That This Train Is A, This Strain Is B. If I Stop This, A Has To Cover 220 Meter
To Actually Overcome It Or Actually To Cross It. So In What Time? So Let Me
Find Out The Relative Speed Of. D With Respect To B. Again This Will Be
Velocity Of A Minus Velocity Of B. Both Are Running Opposite. This Time We
Are Taking Right Hand Side As Positive. So A Is Moving At A Speed Of 40 And
B Is Moving At A Speed Of 32. So 40 -, -, 32. This Will Give You 72 Kilometer
Per Hour. 72 Meters Per Hour. That Means That Is Equal To 20m Per Second.
20m Per Second. Now Time Taken. Will Be Distance Upon Speed. So Let Me
Say That This This Is Distance D IST Upon Velocity Of A With Respect To B.
This Is What We Have To Put. So Distance Is 220 / 20. So We Are Getting 11
Second As The Answer. Right Answer Will Be 11 Second. So Let Me Take The
Right Answer That Is 11 Second.
11th Assignment

The Next Question That We Have Is Explain The Defect Life Cycle What Are
The Different Phases Involved? So You Guys Already Know What Bug Is We
Already Discussed This Many Times. Our Work Is Actually An Error That Could
Have Been Introduced In The Due Course Of Software Development Life
Cycles Due To Multiple Reasons. The Common Sources Of Bugs Are It Can Be
Ambiguous Requirements, Programming Errors, Unachievable Deadlines, And
Much More. Every Reported Bug Actually Follows. A Life Cycle Till Its Closure.
A Bug Life Cycle Basically Illustrates The Journey Of A Bug From The Time It
Is Reported To The Time It's Fixed And Closed. So Let's Quickly Go Through
The Steps That Are Involved In Defect Lifecycle Or Bug Life Cycle. First If We
Have Something Called New State Well In This Step. If A Defect Is Locked And
It's Posted For First Time, Its State Is Given As New. Then You Have Assigned
State. So After The Tester Has Posted The Bug, The Lead Of The Testing Team
Approves That The Bug Is Genuine And He Assigns The Bug To Corresponding
Developer And The Developing Team To Solve It. Then It's Said To Be In
Assigned State. After That You Have Two Other Status Which Says Open And
Fixed. So In Open State Developer That Actually Start Analyzing The Bug And
Start Fixing It. Once He's Sure That He's Fixed The Defect, He Changes The
State Of The Bug To Fixed. Next Up We Have Test Date. So At This Stage
Tester Does The Testing Of Change Code Which The Developer Has Given
Back To Him. So Basically Here The Test Is Checking If The Bug Which She
Has Assigned To Developer Has Been Fixed Or Not. So Once He's Verified, It
Changes The Status Of The Bug To Verify. Now In Case If The Bug Still Exists
Even After The Bug Is Being Fixed By The Developer, The Tester Might Decide
To Reconsider The Bug In Such State At Goes To Reopen State. Now Is The
Tested Things Are Bug Is Fixed. He Marks The Status As Closed. There's
Another State Called Duplicate In The Bug Life Cycle. If Bug Is Repeated
Twice Or There Are Two Bugs Which Deal With The Same Concept, Then One
Bug Status Is Changed To Duplicate. After That You Have Rejected And
Deferred Rejected Is If The Developer Feels That Bug Is Not Genuine, He
Rejects The Bug. And The Status Of The Bug Is Changed To Reject. Deferred
Of The Bug Is Changed To The First Date, It Means That Bug Is Expected To
Be Fixed In Next Few Releases. It's Quite Simple. If You Have Any Queries In
This Defect Lifecycle, You Can Actually Go Ahead And Refer To Software
Testing Tutorial By Edureka. The Entire Life Cycle Is Explained In Detail. So I
Expect This Concept Is Much More Clear For You Guys. Now Let's Move On To
The Next Question. What Is A Test Harness In Testing? Explain. In Software
Testing, A Test Harness Or Automated Test Framework Is A Collection Of
Software And Test Data Configured To Test A Program Unit By Running It
Under Multiple Conditions And Monitoring Its Behavior And Output For All
These Conditions. So Basically It's A Collection Of Software And Test Data
Configured To Test A Program Under Multiple Conditions By Monitoring Its
Behavior And Its Output. Test Harness Has Two Important Parts, Test
Execution Engine And Test Script Repository. A Test Harness Should Allow
Specific Tests To Be Run, It Should All Get Straight A Runtime Environment
And It Should Also Provide A Capability To Analyze The Results. Moving On To
Our Next Question, What Is Test Closure? Will Test Closure Is A Document
Which Gives A Summary Of All The Tests Which Are Conducted During The
Software Development Life Cycle And It Also Gives A Detailed Analysis Of
Bugs Removed And There's Font. So This Document Or Memo Actually
Contains The Total Number Of Experiments, Total Number Of Experiments
Executed, Total Number Of Imperfections Form And Total Number Of
Imperfections Settled, Total Number Of Bugs Or Imperfections Not Settled.
Total Number Of Bugs Rejected, Total Number Of Bugs Differed And So Forth.
So In Simple Terms Test Closure Is A Document Which Has Like Summary Of
All The Tests That Are Conducted During Entire Software Development And
Testing Life Cycle. Next Question That We Have Is Very Basic Question,
What's The Difference Between Positive And Negative Testing And Manual
Testing. So Positive Testing Means Actually Testing The Application Or System
By Giving Valid Data. Whereas Negative Testing Means Testing Application Or
System By Giving Invalid Data. So Positive Testing It Determines That Your
Application Is Working As Expected, Whereas Negative Testing It Ensures
That Your Application Can Run Gracefully And It Can Handle Invalid Input And
Unexpected User Behavior In A Very Proper Manner. Positive Testing Is Always
Done To Verify Known Set Of Test Conditions, Whereas Negative Testing Is
Always Done To Break The Project And The Product With Unknown Set Of
Test Conditions. Positive Testing Checks How The Product And The Project
Behave By Providing The Valid Set Of Data There Is Negative Testing Checks
How The Application Will Actually Perform If We Provide The Invalid Output,
Will It Actually Deal With It Or Give The Wrong Output Or What Would Be The
Result? That's Negative Testing. So That's The Basic Difference Between
Positive And Negative Testing. So Next Question That We Have Is Define
What's Critical Bug. Well, A Critical Bug Is A Bug That's Got Tenancy To Affect
Majority Of Functionality Of A Given Application. It Means That A Large Piece
Of Functionality Or A Major System Component Is Completely Broken And
There's No Way To Walk Around It. Application Cannot Be Distributed To End
Client Users If The Critical Bug Has Not Been Issued Remember That. Moving
On To Our Next Question, What Is Pesticide Paradox And How Do You
Overcome It? If Same Test Cases Are Repeatedly Run Over And Over Again,
Eventually They Will No Longer Will Help You Find New Bugs And This
Concept Is Called Pesticide Paradox In Testing. After Certain Number Of
Iterations Of Testing, As The Testing Improves, The Defect Number Actually
Starts Dropping And Most Of The Bugs Will Actually Be Fixed. So Developers
Will Be Extra Careful In Only Those Places Where Testers Found More Defects
And They Might Not Look In Other Areas. This Is What You Call Pesticide
Paradox. So How You Actually Go Ahead And Overcome This Pesticide
Paradox? Do You Have Any Solutions? Well, Yes, You Can Go Ahead And Write
Whole New Set Of Test Cases To Exercise Different Parts Of The Software And
You Can Prepare New Test Cases And Add Them To Your Existing Test Cases.
So By Following Above 2 Methods Of Prevention, It's Possible To Find More
Potential Defects In The Area Where You Might Have Actually Missed
Previously Or Where You Might Have Neglected This. So That's What Pesticide
Paradox Is And How We Overcome It. Moving On To Next Question, What Is
Defect Cascading In Software Testing? So Defect Cascading Is Process Of
Triggering Other Defects And Application. Simple Right? It's Just Triggering
Other Defects In Application. When A Defect Goes Unnoticed While Testing, It
Invokes Other Defects. Well, As A Result Multiple Defects Crop Up In Later
Stages Of Development. If Defect Cascading Continues To Affect Other
Features In Your Application, Identifying The Affected Actually Affected
Feature Becomes Very Challenging. You Might Actually Go Ahead And Take
Different Test Cases To Solve This Issue Even It's Difficult And Time
Consuming. Let Me Give You A Simple Example To Understand The Concept.
So An Application Has Been Deployed To Calculate A Monthly Salary Of The
Employees. The Module Which Is Responsible For Calculating Salaries Is
Having An Unidentified Defect. As A Result, It's Wrongly Calculating The
Salary. This Prompts The Database To Transmit Incorrect Salary Numbers,
Which Are Further Reflected In Your Balance Sheet, Tax Calculations And
Wherever The Salary Part Is Used. So One Defect Is Triggering Other Defects
In Application, That's What Defect Cascading Is. Let's Move On To Our Next
Question, Which Is What Do You Actually Mean When You Say A Quality
Software? So In General, Quality Software Is Reasonably Bug Free. It's
Delivered On Time And Within Budget, It Meets The Given Requirements Or
Expectations, And It's Highly Maintainable. But Again, Quality Is Always A
Subjective Term. It Will Depend On Who The Customer Is And Their Overall
Influence In The Schema Of Your Testing. For Example, Each Type Of
Customer Will Have Their Own Slant For Quality. The Accounting Department
Might Define Quality In Terms Of Profit, Whereas If You Ask A General End
User, He Might Define Quality As User Friendly, Safe And Bug Free. So Again,
Quality Is A Subjective Term. The Next Question That We Have Is What Is
Black Box Testing And What Are Various Techniques That Come Under Black
Box Testing. So Black Box Testing Is Also Known As Specification Based
Testing. It Analyzes The Functionality Of The Application Without Knowing
Much About The Internal Structure Or Design Of The Application That's Being
Tested. So What's The Purpose Of Black Box Testing? Well, It's To Check The
Functionality Of The System As A Whole To Make Sure That It Works Correctly
And It's Meeting The User Demands. You Have Various Techniques That Pop
Up Under Black Box Testing Like You Have Equivalence Partitioning, Use Case
Testing, Cause Effect Graphing, And Many Others.

12th Assignment

As You Can See, The Class Edureka Two Has Successfully Implemented Both
The Methods From Interface One And Interface Two And Display The Output. I
Have Given Three As The Input For Finding Whether It Is Prime Number Or
Not And The Result Is It Is A Prime Number. Similarly, I Have Given One Fifty
Three To Find Out If It Is An Armstrong Number Or Not And The Program
Provided The Output As It Is An Armstrong Number. With This, Let Us
Continue With Our Key Points. The Next One Is Access Modifiers In An
Interface. Interface Can Be Declared As Private, Protected And Transient. All
The Interface Methods By Default Are Abstract And Public. Variables Declared
In Interface Are Public, Static And Final. By Default. Interface Variables Must
Be Initialized At The Time Of The Declaration, Otherwise The Compiler Will
Throw An Error Inside Any Implementation Class You Cannot Change The
Variables Declared In An Interface. Let Us Discuss Each One Of These Points
Practically. Here I Have Defined An Interface By Name Try Here I'm Trying To
Declare An Integer Type Variable A Using Int A Is Equals To Ten Which Is Valid
And Similarly You Can Do It By Using An Access Modifier Public Which Is
Same As A Previous One. And You Can Also Declare This Variable By Using
Public Access Modifier And Making It As Static And Final. The Variable Can
Also Be Declared By Using Final Keyword. And Also In The Static Keyword All
The Above Stand The Same. Now Let Us See The Next Point Which We
Discussed In Our Access Modifiers. We Discussed That The Variables Which
We Declare In An Interface Must Be Assigned To A Value. Here I'm Trying To
Declare An Integer Type Variable X Without Assigning It To Any Value. Now
Let Us Try To Run This Program And See If There Is An Output Or Not. And I'm
Trying To Access The Same X Here In The Main Class And Let's Execute This
Program. As You Can See, There Is An Error, Which Means That We Were
 Supposed To Assign A Value To The Variable Which We Declared In The
Interface. With This, Let Us Move On To Our Next Stage Of Key Points. The
Next One Is Extending An Interface. An Interface Can Extend Any Number Of
Interfaces But Cannot Implement Them, Whereas A Class Can Implement Any
Number Of Interfaces If There Are Two Or More Same Methods In Different
Interfaces. Then The Class Can Implement All The Interfaces, But One Single
Method Is Enough To Perform The Operation. Our Class Cannot Implement
Two Interfaces That Have Methods With Same Name But Different Return
Type. The Major Advantage Of Using An Interface Is That Variable Name
Conflicts Can Be Easily Resolved By Using The Interface Name. Let Us See
This Practically. As You Can See Here I've Defined An Interface A With The
Method Display And Similarly I Have Also Defined An Interface B With The
Same Display Method Inside It. Now I'm Trying To Implement Both Of
Interfaces A And B In My Class Same And I'm Trying To Access The Display
Method. Let Us Try To Execute This Program And See If This Runs Or Not. As
You Can See The Program Has Been Successfully Compiled. And The Output
Is Being Generated Which Is Displaying Data. Now Let Us Discuss The Next
Point. Here I've Defined An Interface A Which Has The Variable X Of Integer
Data Type Storing The Value Thousand And Similarly I Have Also Defined
Another Interface With Name P Which Has The Same Variable X Which
Storing Different Value. Now In My Main Program If I Try To Access The
Variable X Then It Might Provide Me An Ambiguity. But If I Use The Interface
Name Then I Can Successfully Access Both The Variables And Display The
Data Present In Them Without Facing Any Of The Ambiguity. Now Let Us
Execute This Program And See The Output. As You Can See, The Value Of X In
The First Interface A Was Thousand, Which Is Displayed Here, And The Value
Of X In The Second Interface, Which Is Two Thousand, Is Also Being Displayed
Here. I've Used The Interface Name A And Interface Name B In The Print
Statement Provided Here. Let's Understand What Our Data Structures In
Java. A Data Structure Is A Way Of Storing And Organizing The Data In A
Computer So That It Can Be Used Efficiently. It Provides Some Means To
Manage Large Amounts Of Data Efficiently, And Efficient Data Structures Are
Key To Designing Efficient Algorithms. Next, We Have Two Types Of Data
Structures, That Is Linear And Hierarchical. So What Is Linear Data
Structures? Linear Data Structures Are Those Whose Elements Are Sequential
And Ordered In A Way So That There Is Only One First Element And Has Only
One Next Element. There Is Only Last Element And Has No Previous Element
While All The Other Elements. Have A Next On A Previous Element.
Understood Like You Can Have Only First And The Next Element And There Is
Only Last Element. But Has Only One Previous Element. So There Cannot Be
 Any Multiple Previous Elements Or Multiple Next Elements. OK, But All The
Other Elements Have A Next And Previous Element. Note That There Is Only
One Previous And Next Elements. Simple. So Based On These Categories.
Linear Data Structure Are Being Divided Into Stack Queue And Linked List.
Now Talking About The Stack. Stack Is An Abstract Data Structure. It Is A
Collection Of Objects That Are Inserted And Removed According To The Last
And First Out Principle That Is LIFO. Objects Can Be Inserted Into A Stack At
Any Point Of Time. But Only The Most Recently Inserted, That Is The Last
Object Can Be Removed At Anytime. So You Can See Here This Is A Bottom
Element And This Is A Top Element. When You Push The Element Into The
Stack, It Goes Into The Bottom And The Last Element That Is The Top
Element Can Be Popped Out. So Once The Top Element Is Popped Out, The
Next Element Which Is Available In The Stack Can Be Popped Out But The
Bottom Element Cannot Be Popped Out First. Understood. So This Is How It
Works. That Is, It Is An Ordered List In Which Insertion And Deletion Can Be
Performed At Only One End, That Is The Top. It Is A Recursive Data Structure
With A Pointer To Its Top Element. It Supports 2 Fundamental Methods That
Are Push That Is, You Can Insert The Element To The Top Of The Stack And
Pop Remove And Return The Top Element Onto The Stack. So If I Have To
Give You An Example, It Can Be Reversing A Word To Check The Correctness
Of A Parenthesis Sequence, Implementing Back Functionality In Browsers And
Many More. Now Let's See A Small Example Of Stack. So I Have Created A
Class Called Stack And The Maximum Capacity Of The Stack Is Thousand.
And As I Told, We Need An Element Called Top, Right? Because It's A Main
Thing. So That's The Reason. And Then I'm Initializing The Maximum Size Of
Stack. So There Are Two Conditions. First Is Empty. So If The Stack Is Empty,
Then Return Top Less Than Zero. Because There's No Element In The Top
When Stack Itself Is Empty, Then There's Nothing, Right? That's The Reason.
And Then I'm Creating A Constructor For Stack And Initializing The Top Size To
- One Because Nothing Is There. Next What I'm Doing, I'm Pushing The
Element Into The Stack, So If Stop Is Greater Than Or Equal To Maximum
Size- One Then Print Stack Overflow, Return False, Else Insert The Element To
The Top Of The Stack And Initialize It To The Variable As This X Which Is This
One. Next Say That So This Element Which Is The Element That You Have
Inserted Into The Stack Is Pushed Into The Stack OK Then Return Then Again
I'm Creating A Method Called Pop That Is Removing The Element Out Of The
Stack. So If Stop Is Less Than Zero Then Say Track Underflow Else In X Is
Equal To Delete One Element From The Stack That Is A Of Top Minus Minus
Then Return X Again. I'm Creating One More Method Called Peak. If Top Is
Less Than Zero Then Say Stack On The Floor, Else Return The Element At The
 Top Of The Stack And Return Send It To X That Is The Element Which You
Have Taken It Over Here Simple. Now I'm Writing A Driver Code That Is The
Main Method. I'm Initializing A Stack And Creating An Object Of A New Stack
And Sending Elements Push Ten, Push Twenty And Push Thirty And Then
When All These Elements Are Inserted Into The Stack, If I Want Again, I Can
You Know Say Push Forty. So When I Use S . Box So What Do You Think? Well,
This Element Will Be Popped Out First Or This Element, Obviously This
Element, Right? So Now Let's Run And Check For The Output. So You Can See
First Ten Was Pushed Into The Stack, Twenty Was Pushed, Thirty Was Pushed
Into The Stack, And Then Forty. But When I Used Extra Bob, The Last Element
Was Popped Out So If I Don't Have This Element, I'll Just Save This. Now See
The Last Element Which Is Thirty Is Popped Out From This Stack, Right? So
This Is How You Can Execute Your Stack And These Are The Operations That
Is Performed On A Stack. So This Is How It Works. Now Talking About The
Next Data Structure That Is Queue Is Also Another Type Of Abstract Data
Structure. Unlike A Stack, The Queue Is A Collection Of Objects That Are
Inserted And Removed According To First In First Out Principle. That Is,
Elements Can Be Inserted At Any Point Of Time, But Only The Element That
Has Been In The Queue The Longest Can Be Removed At Any Time.

13th Assignment

You Can See The Output Has Been Successfully Generated And The Output
Before Adding Two New Elements Are How Are? To Edureka Here I'm Adding
You And Welcome Into This Particular Linked List In A Designated Location,
Which Is Two And Four. So After Adding Two New Elements, This Particular
Linked List Is Making A Sensible Statement, Which Is How Are You? And
Welcome To Edureka. Now Let Us Try To Execute Clear Method. As You Can
See In This Particular Example, I Have Created A Linked List And I Have Also
Added Some Elements Into The Linked List Which Is Edureka Online Training
Institute. After That I'll Be Clearing The Linked List Using The Command List
Dot Clear Once After I Clear The List. The Linked List Becomes Completely
Empty. After That I'll Be Using The Add Method Again To Add Up New
Elements Into The Linked List. So Now Here The Linked List Will Be
Completely Erased In The First Half And After That Once If I Try To Insert New
Elements Into It, Then It Will Take Up The New Elements And Add Them Into
The Previously Existing Blocks. Without Having The Previous Data In The
Linked List. Now Let Us Try To Execute This Program And See How Does It
Work And Understand It In A Better Way. As You Can See, The Data Has Been
Successfully Generated And The Data Which Is Present In The Linked List
Before Clearing Was Edureka Online Training Institute. Once After The Data
Has Been Cleared Successfully, The New Elements Have Been Added Into
The Linked List. Which Are Now Tide Up With NIT Or angel. Now Let Us Try To
Execute Clone Method. In This Particular Example, I'll Be Using Clone Method.
The Clone Method Is Nothing But You're Cloning The Existing Link List. Now
Let Us Try To Execute This Program And Understand This In A Better Way. As
You Can See The First Link List Is Example Four Clone Method. I'm Using
Clone Method And I'm Trying To Duplicate The First Linked List Which Has The
Same Data As You Can See Which Is Example For Clone Method. Now Let Us
Try To Execute Index Method. As You Can See In This Particular Example I'm
Using Index Of Method. So Here I Have Inserted Some Data Into My Linked
List Which Is Using Index Of Method. So What I'll Do Here Is I'll Be Using List
Dot Index Of Method To Find Out The Index Of A Particular Element. So Here
I've Chosen Using Element And Method Element To Find Out The Index Of
Those Particular Elements. Let Us Try To Execute This Program And See How
Does It Work. As You Can See The Output Is Been Successfully Generated
And The Linked List Was Using Index Of Method. Now The Index Of The
Element Called Using Is Zero And The Index Of The Element Method Is Index
Three. Now Let Us Execute Offer Method. As You Can See In This Particular
Method I Have Created A Linked List And Added The Elements BMW, Porsche
And Mercedes And I'm Using Offer Last Method To Add The Final Element
Which Is Jaguar To The Linked List. So Let Us Try To Execute This Program And
See How Does It Work. As You Can See, The Output Has Been Successfully
Generated And The Elements In The Linked List Before Using Offer Last Were
BMW, Porsche And Mercedes And The Elements After Executing Using The
Offer Last Method Is BMW, Porsche, Mercedes And Jaguar Where The Element
Jaguar Is Included Into The Linked List At The Last Section Which Happens To
Be The Deal. Now Let Us Execute Offer First Method. In This Particular
Example, I'm Creating A Linked List Which Will Be Having The Elements C
Language, Java And Kotlin. And Finally I'll Be Using The Offer First Method
Where I'll Be Including The Python Element And The Head Section Of The
Linked List. Now Let Us Execute This Program And See How Does It Work. As
You Can See The Python Element Is Included Here At The Head Section. Now
Let Us Try To Execute Pop Method. In This Particular Example, I Have Pushed
In Two Elements Which Is A And B And Here I'll Be Using The Pop Method To
Pop The Last Element Which Is Pushed Into The Stack And After That I'll Try
To Push A New Element Which Is See In To The Stack And Finally We'll Print
The Stack Which Is Existing Right Now. Let Us Try To Execute This Program.
As You Can See, The Last Element Which Was Pushed Into The Stack Was B
And After Popping It, We Have The Elements C And A Which Are Existing In
The Current Stack. Now Let Us Try To Execute The Push Example. As You Can
See, This Particular Example Is Similar To The Previous One. Here We Are Just
Pushing The Elements Into The Stack Using The Stack Push Method. As You
Can See, The Output Has Been Successfully Generated And The Elements
Which We Have Pushed Into The Stack Are Hundred Two Hundred And Three
Hundred. Now Let Us Try To Execute A Remove Method. As You Can See In
This Particular Example I'm Trying To Insert Four Elements Into The List Which
Are Apple, Banana And Grape. And Here I'm Using List Dot Remove Method
To Remove One Element From The Linked List Which Is The First Element
Which Happens To Be Apple. Now Let Us Try To Execute This Program And
See How Does It Work. As You Can See, The Elements Before Removing The
Element Apple Are Apple, Banana, Grape And Pineapple. So Once After I
Remove The First Element, The Remaining Elements Are Banana, Grape And
Pineapple. Let Us Try To Execute The Set Method. In This Particular Example,
I'll Be Using List Dot Set Method. Here I'm Trying To Set Two Elements Into
The Linked List Which Are Kiwi And Orange At The Position Two And Three. As
You Can See This Is The Element Kiwi And This Is The Element Orange And
I'm Trying To Set Kiwi Into The Position Number Two And Orange Into The
Position Number Three. Let Us Try To Execute This Program To Understand
This In A Better Way. As You Can See, The Output Is Being Successfully
Generated And The Elements Before Inserting Them Into The Second And
Third Position Are Apple, Banana, Grape And Pineapple. The Objects Grape
And Pineapple Which Were At The Positions Two And Three Are Replaced With
Kiwi And Orange. Now Let Us Try To Understand Size Method. Size Method Is
Not A Complicated Method. All It Does Is Shows The Number Of Elements
Which Are Present In An Array. Now Let Us Try To Execute This Program And
Find Out The Size Of The Particular Linked List. As You Can See I'm Using List
Dot Size Over Here And I'll Be Finding Out The Size Of This Particular Linked
List. Now Let Us Try To Execute This Program. As You Can See, The Link List Is
Apple, Banana, Grape And Pineapple And Size Of This Particular Link List Is
Four. Now Let Us Try To Convert An Array Into The Linked List. As You Can See
In This Particular Example, I'm Trying To Add The Array Which Is Courses
Which Has Java, PHP, Hadoop, DevOps And Python Elements Into A Linked
List. So Here I'm Using For Loop Into Which I'll Be Adding The String As
Elements Which Are Courses Into The Linked List Which Is A Course List.
Using The Add Method. Now Let Us Try To Execute This Program And See How
Does It Work. As You Can See, The Elements In Java, PHP, Hadoop, Devops
And Python Were Actually The Elements Of An Array Called Courses. And
Using The Add Method We Have Added The Elements Of An Array Into The
Course List Which Happens To Be The Linked List. And Here The Output Has
Been Printed Successfully Which Happens To Be The Output Of A Linked List.
Now Let Us Try To Convert A Linked List Into An Array. In This Particular
Example, I've Used Add Method To Add The Java, Python, DevOps, Hadoop
And AWS Elements Into A Linked List Called As Course List. Now We'll Be
Using To Array Method To Add All The Elements Which Are Present In A Linked
List Into An Array. Now Let Us Try To Execute This Program And Understand
This In A Better Way. As You Can See The Size Of The Linked List Was Five.
The Elements Of The Linked List Were Java, Python, Hadoop, DevOps And
AWS Which Are Now Included Into The Array Called As Numbers Which Is
Displayed As Follows Java, Python, DevOps, Hadoop And AWS. So These Are
The Elements Which Are Present In The Array Called As Numbers. So We
Have Successfully Converted A Linked List Into An Array. Now Let Us Discuss
The Major Differences Between Aries And Linked List. The Aries Are Not
Responsible Because The Size Of The Array Is When Defined At The
Declaration Section Itself. But On The Other Hand, Linked Lists Are
Dynamically Resizable. The Next Difference Is The Add Is Offer More Methods
Compared To Linked List While The Linked List Are Concise To Few Methods
Compared To Arrays. The Third Difference Is The Arrays Have Insertion,
Addition And Removal Operations Done In A Faster Way While In Linked List
You Have To Traverse From Head To Tail.

14th Assignment

It's The Formal Testing That's Performed Based On User Requirements And
Function Processing. This Acceptance Testing Actually Covers End Users Real-
World Scenarios And This Last Level Needs To Be Done Correctly Because It
Provides You With The Result On The Basis Of If The Software Product It's Fit
To Be Released To The Market Or Not. So, Yeah, These Are Four Levels Of
Manual Testing. So The Next Question That We Have Is What's The Difference
Between Quality Control And Quality Assurance. We Did Already Talk About
What Quality Control Is. Quality Control Is Set Of Activities For Ensuring
Quality In The Product. So The Activity Is Focused On Identifying Defect's And
Actual Product Produced. Where Is Quality Assurance Instead Of Activities For
Ensuring Quality In The Processes By Which Product Are Developed? So You
Get My Point Right. Quality Control Is A Product Oriented Approach You're
Checking The Quality Or Defects In The Product, Which Is Quality Assurance
Is A Process Oriented Approach. You're Checking The Quality Of The Process
By Which Products Are Developed. So Quality Control Aims To Identify
Defects In The Finished Product. Therefore, It's A Reactive Process, Whereas
Quality Assurance Prevents Defects With A Focus On Processes Which Are
Used To Make The Product. Therefore It Is A Proactive Process. I Hope The
Difference Is Clear. Let Me Summarize. Quality Control Is A Product Oriented
Approach Of Running A Program To Determine If It Has Any Defects As Well
As Making Sure That Software Needs All The Requirements Put Forth By End
User And Stakeholder That Is Quality Assurance Is A Process Oriented
Approach That Focuses On Making Sure That Methods, Techniques And
Processes Which Are Used To Create The Product Meets The Quality
Standard. The Next Question That We Have Is What Is A Test Bed In Manual
Testing? Explain With Help Of An Example. Test Bed In Simple Terms Is A Test
Execution Environment Which Is Configured For Testing. It Consists Of
Hardware, Software, Network Configuration, Application Which Is Under Test,
Operating System Settings, Software Configuration, Test Terminals And Much
More. So In Simple Terms It's A Test Execution Environment Which Is
Configured For Testing. Well, A Typical Test Bit For A Web-Based Application
Looks Something Like This. You Have Java Version Listed Out. You Have The
Browser That You're Using Listed Out Operating System Settings Like
Windows Or Linux, Then The Database That You're Using, Web Server Et
Cetera. It Has All The Details Which Are Required For You To Perform Tests.
Next Question Is Explain The Procedure For Manual Testing. Well, It's Quite
Simple And Similar To Any Other Standard Software Testing. First Of All You
Start By Understanding The Requirements Which Are Put Forth By The Users
Based On The Requirements You Write The Test Cases And After That You
Conduct The Test Case That You Written And Categories. Once You've
Conducted The Test And You Have Your Result, You Create Good Bug Report
Which You Will Have To Submit To Your Manager Or Higher Level People In
The Next Stage. Simple Enough, Right? You Start With Understanding The
Requirements Put Forth By The Users. You Categorize The Requirements And
Right Test Cases And Separate Them Into Different Groups To Make It Much
More Easier To Identify. Once You Have Your Test Cases, You Execute Them
And Once You Get The Results, You Create Reports And Submit The Reports
To Higher Authorities. So That's The General Procedure That You Follow When
Performing Manual Test. The Next Question Is What Exactly Is Test Case
Explained With An Example. Guys Documentation Plays A Very Important
Role In Testing, Beat Manual Testing Or Automation Testing. A Test Case Is
One Of The Documentation Used. It's A Document Which Has Set Of
Conditions Or Actions That Are Performed On Software Application In Order To
Verify The Expected Functionality Of A Feature. So basically Test Cases
Describe A Specific Idea That Is To Be Tested Without Actually Detailing The
Exact Steps To Be Taken Or Data To Be Used, For Example, Let's Say In A Test
Case, Your Document Looks Something Like This ‘Test F Coupons Can Be
Applied To Actual Price’. So That's Your Test Case Statement. Let Me Read It
Again. Test If Coupons Can Be Applied On Actual Price. So As You Can Notice,
This Statement Doesn't Actually Mention How To Apply The Coupons. Or
Whether There Are Multiple Ways To Apply Or Not, It Doesn't Mention A Tester
Uses A Link To Apply Discount Or Does He Enter A Code Or Does He Have A
Customer Service To Applied? It Doesn't Go Into Much Details. It Just
Specifies The Major Objective Of Testing In Simple Terms. So This Test Cases,
They Give Flexibility To Tester To Decide How They Want To Execute The Test.
Next Question That We Have Is What Is API Testing. API As You Guys Might
Know As An Acronym For Application Programming Interface, Which Is A
Software Intermediate Tree That Allows Two Applications To Talk To Each
Other. So API Testing Is A Type Of Software Testing Where Apis Or Application
Programming Interfaces Are Tested To Check If They Meet Expected
Functionality, Reliability, Performance And Security. API Testing Really Need
It. Reveal Box Inconsistencies And Deviations From The Expected Behavior Of
An API. Well, To Be Honest, API Testing Office Lot Of Advantages Like It's
Language Independent First Of All And Its Graphical User Interface
Independent. It Offers Improved Test Coverage, It Reduces The Testing Cost,
It Enables Faster Releases And All That. On Top Of That, One More Thing That
You Remember Is Basically Application Is Divided Into Three Stages. You Have
Presentation Day, Then You Have Business Layer And Database Layer. So API
Testing Is Usually Performed In Business Layer. Let's Move To Next Question.
Let's See What That Is. So What's The Difference Between Verification And
Validation In Manual Testing? It's Software Testing. Verification Is A Means To
Confirm That The Product Development Is Taking Place According To The
Specifications And Using Standard Development Procedures. It Consists Of
Different Activities Like You Have Reviews, Inspection, Walkthroughs, Demos
And All That. So Basically You're Confirming That The Product Development Is
Taking Place According To The Requirements, Specifications And Using
Standard Procedures. Now Coming To Validation, It's A Means To Confirm That
The Developed Product Doesn't Have Any Bugs And It's Working As
Expected. It Consists Of Activities Like Functional And Non Functional Testing
Techniques. So That's The Difference Between Verification And Validation.
Moving On To Next Question, What's The Difference Between A Bug And A
Defect? So Defect Is Simply Defined As A Variance Or Difference Between
Expected And Actual Result, It's An Error Found After The Application Goes
Into Production. It Commonly Refers To Several Troubles With Software
Products, With Its External Behavior Or With Its Internal Feature. So The Key
Point Is Defect Is An Error Which Is Found After The Application Goes Into
Production. Coming Back To Bug. Bug Is A Result Of A Coding Error, An Error
Which Is Found In The Development Environment Before The Product Is
Shipped To The Customer. A Programming Error That Causes A Program To
Work Poorly Produce Incorrect Results Of Crash The System. That's A Park. Or
It Can Be An Error In Software Or Hardware That Causes A Program To
Malfunction Entirely. Bug Is a Terminology Of A Desktop? Now You Understand
The Difference, Right? Defect Is The Difference Between Expected And
Actual Result And It Occurs After The Application Goes Into Production.
Whereas Bug Is Result Of A Coding Error. Like You Said It Can Be Anything. So
It's Error That's Developed Before The Product Is Shipped To The Customer.
Moving On, The Next Question That We Have Is What Are Advantages Of
Manual Testing. Manual Testing Is A Lot Of Advantages To Offer First Of All You
Have Live Testing So With Manual Testing, Testofen Test The Application
Under Similar Condition When Your Application Goes Live. So Any Bugs Or
Glitches Which Are Common Application Is Life Can Be Easily Tracked With
Help Of Manual Testing. Secondly, Manual Testing Less Programming
Knowledge Is Required. Basically When You're Testing An Application
Manually, Your Main Focus Is On Understanding Requirements, Documenting
The Test Cases. And Executing The Test Cases. Then There's This Case Of UI
And UX Issues When It Comes To Automation Testing. So Basically,
Automated Tests Are Quite Literally Robotic, Right? They Fail To Act As A Real
End User Would. But Manual Testing Helps Test You To Identify Any Issues
Which Are Related To Look And Feel Of The Application. It Also Helps To Find
Out The Usability Issues In The Application On Top Of All That. Manual Testing
Required Really Low Investment As It Doesn't Require Any Costly Tools For
Highly Skilled People To Be Hired. So What I Meant To Say Is Initial
Investment In Manual Testing Is Very Low And Manual Testing Is Cost
Effective For Short Term Projects. Lastly, In Manual Testing You Can Swiftly
Test And See The Outcomes. So It's Once Suited In Cases When You're
Making Lot Of Unplanned Changes To Your Application. And Also It Application
Needs To Be Tested Immediately After Implementing These Changes. In Such
Cases Manual Testing Is Really Effective. Let's Move On To Our Next Question
Which Is What Are Disadvantages Of Manual Testing? Apart From The Pros It
Offers, It Has A Lot Of Demands As Well. First Of All, It's Really Time
Consuming. Manual Test Cannot Be Reused, Which Means Every Time There's
A Change In Your Application, The Tester Needs To Run. All The Test Cases
Again, Well This Is Rather Time Consuming Activity And That Is Why Manual
Testing Is Really Time Consuming. Then You Have Like Testing Limitations You
Can't Go And Apply Manual Testing For Performing Load And Performance
Testing.

15th Assignment

It's The Formal Testing That's Performed Based On User Requirements And
Function Processing. This Acceptance Testing Actually Covers End Users Real-
World Scenarios And This Last Level Needs To Be Done Correctly Because It
Provides You With The Results On The Basis Of If The Software Product Is Fit
To Be Released To The Market Or Not. So Yeah, These Are 4 Levels Of Manual
Tests. So The Next Question That We Have Is What's The Difference Between
Quality Control And Quality Assurance. We Did Already Talk About What
Quality Control Is. Quality Control Is Set Of Activities For Ensuring Quality In
The Product. So The Activities Focus On Identifying Effects In Actual Product
Produced Where Is Quality Assurance Is Set Of Activities For Ensuring Quality
In The Processes By. Product Or Develop. So You Get My Point Right. Quality
Control Is A Product Oriented Approach. You're Checking The Quality Or
Defects In The Product, But It's Quality. The Insurance Is A Process Oriented
Approach. You're Checking The Quality Of The Process By Which Products Are
Developed. So Quality Control Aims To Identify Defects In The Finished
Product. Therefore It's A Reactive Process, Whereas Quality Assurance
Prevents Defects With The Focus On Processes. Which Are Used To Make The
Product. Therefore It Is A Proactive Process. I Hope The Difference Is Clear.
Let Me Summarize. Quality Control Is A Product Oriented Approach Of
Running A Program To Determine If It Has Any Defects As Well As Making
Sure That Software Meets All The Requirements Put Forth By End User And
Stakeholder. Whereas Quality Assurance Is A Process Oriented Approach That
Focuses On Making Sure That Methods, Techniques. And The Processes
Which Are Used To Create The Product Meets The Quality Standard. The Next
Question That We Have Is What Is A Test Bed In Manual Testing? Explain With
Help Of An Example. Test Bed In Simple Terms Is A Test Execution
Environment Which Is Configured For Testing. It Consists Of Hardware,
Software, Network Configuration, Application Which Is Under Test, Operating
System Settings. Software Configuration, Test Terminals And Much More. So
In Simple Terms It's A Test Execution Environment Which Is Configured For
Testing. Well, A Typical Test Kit For A Web-Based Application Looks Something
Like This. You Have Java Version Listed Out, You Have The Browser That
You're Using Listed Out, Operating System Settings Like Windows Align X,
Then The Database That You're Using, Web Server Etc. It Has All The Details
Which Are Required For You To Perform This. Next Question Is Explain The
Procedure For Manual Testing. Well, It's Quite Simple And Similar To Any
Other Standard Software Testing. First Of All, You Start By Understanding The
Requirements Which Are Put Forth By The Users. Based On The Requirements
You Write The Test Cases And After That You Conduct The Test Cases That You
Have Written And Categorized. Once You've Conducted The Test And You
Have Your Result. To Create Good Bug Report Which You Will Have To Submit
To Your Manager Or Higher Level People In The Next Stage. Simple Enough,
Right? You Start With Understanding The Requirements Put Forth By The
Users. You Categorize The Requirements And The Right Test Cases And
Separate Them Into Different Groups To Make It Much More Easier To Identify.
Once You Have Your Test Cases, You Execute Them And Once You Get The
Results You Create. The Report And Submit The Reports To Higher Authorities.
So That's The General Procedure That You Follow When Performing Manual
This. The Next Question Is What Exactly Is Test Case Explanation Example
Guys, Documentation Plays A Very Important Role In Testing Page Manual
Testing Or Automation Testing. A Test Case Is One Of The Documentation
Used. It's A Document Which Has Set Of Conditions Or Actions. Set Up
Performed In Software Application In Order To Verify The Expected
Functionality Of A Feature. So Basically Test Cases Describe A Specific Idea
That Is To Be Tested Without Actually Detailing The Exact Steps To Be Taken
Or Data To Be Used. For Example, Let's Say In A Test Case Your Document
Looks Something Like This Quotation Test If Coupons Can Be Applied To
Actual Price. Quotation Close So That's Your Test Case Statement. Let Me
Read It Again. Test If Coupons Can Be Applied On Actual Price. So As You Can
Notice This Statement Doesn't Actually Mention How To Apply The Coupons
Or Whether There Are Multiple Ways To Apply Or Not. It Doesn't Mention If
Tester Uses A Link To Apply The Discount Or Does He Enter A Code Or Does
He Have A Customer Service To Apply It. It Doesn't Go Into Much Details It
Just. Specifies The Major Objective Of Testing In Simple Terms. So This Test
Cases That Give Flexibility To Tester To Decide How They Want To Execute
The Test. Next Question That We Have Is What Is Api Testing? Api As You
Guys Might Know As An Acronym For Application Programming Interface,
Which Is A Software Intermediate Tree That Allows Two Applications To Talk To
Each Other. So Api Testing Is A Type Of Software Testing Where Apis Or
Application Programming Interfaces Are Tested To Check If They Meet
Expected Functionality, Reliability, Performance And Security. Api Testing Is
Really Needed. To Reveal Box Inconsistencies And Deviations From The
Expected Behavior Of An Api. Well, To Be Honest, Api Testing Office Lot Of
Advantages Like It's Language Independent First Of All And Its Graphical User
Interface Independent. It Offers Improved Test Coverage, Introduces The
Testing Cost, It Enables Faster Releases And All That. On Top Of That, One
More Thing That You Remember Is Basically Application Is Divided Into 3
Stages. You Have Presentation Day, Then You Have Business Layer And
Database Layer. So Maybe Your Testing Is Usually Performed In Business
Layer. Let's Move To Next Question. Let's See What That Is. So What's The
Difference Between Verification And Validation And Manual Testing? In
Software Testing, Verification Is A Means To Confirm That The Product
Development Is Taking Place According To The Specifications And Using
Standard Development Procedures. It Consists Of Different Activities Like You
Have Reviews, Inspection, Walkthroughs, Demos And All That. So Basically
You're Confirming That The Product Development Is Taking Place According To
The Requirement Specifications And Using Standard Procedures. Now Coming
To Validation, It's A Means To Confirm That The Developed Product Doesn't
Have Any Box And It's Working As Expected. It Consists Of Activities Like
Functional And Non Functional Testing Techniques. So That's The Difference
Between Verification And Validation. Moving On To Next Question, What's The
Difference Between A Bug And An Effect? So A Defect Is Simply Defined As A
Variance Or Difference Between Expected And Actual Result. It's An Error
Found After The Application Goes Into Production. It Formally Refers To
Several Troubles With Software Products Within The External Behavior Or
With Its Internal Feature. So The Key Point Is Defect Is An Error Which Is
Found After The Application Goes Into Production. Coming Back To Bug, Bug
Is A Result Of A Coding Error. An Error Which Is Found In The Development
Environment Before The Product Is Shipped To The Customer. A Programming
Error That Causes A Program To Work Poorly, Produce Incorrect Results, Or
Crash The System, That's A Problem. Or It Can Be An Error In Software Or
Hardware That Causes The Program To Malfunction Entirely. But Is A
Terminology Of A Desktop. Now You Understand The Difference, Right?
Defect Is The Difference Between Expected And Actual Result And It Occurs
After The Application Goes Into Production. Whereas Bug Is Result Of A
Coding Error. Like I Said, It Can Be Anything. So It's Error That's Developed
Before The Product Is Shipped To The Customer. Moving On, The Next
Question That We Have Is What Are Advantages Of Manual Testing? Manual
Testing Is A Lot Of Advantages To Offer. First Of All You Have Live Testing. So
With Manual Testing, Testing Can Test The Application Under Similar
Condition When Your Application Goes Live. So Any Bugs Or Glitches Which
Are Common Application Is Life Can Be Easily Tracked With Help Of Manual
Testing. Secondly, Manual Testing Less Programming Knowledge Is Required.
Basically When You're Testing An Application Manually, Your Main Focus Is On
Understanding Requirements Documenting The Test Cases And Executing
The Test Cases. Then There's This Case Of Ui And Ux Issues When It Comes
To Automation Testing. So Basically, Automated Tests Are Quite Literally
Robotic, Right? They Fail To Act As A Real End User Would. But Manual Testing
Helps Test You To Identify Any Issues Which Are Related To Look And Feel Of
The Application. It Also Helps To Find Out The Usability Issues In The
Application. On Top Of All That, Manual Testing Requires Really Low
Investment As It Doesn't Require Any Costly Tools Or Highly Skilled People To
Be Hired. So What I Meant To Say Is Initial Investment In Manual Testing Is
Very Low And Manual Testing Is Cost Effective For Short Term Projects. Lastly,
In Manual Testing You Can Swiftly Test And See The Outcomes. So It's Well
Suited In Cases When You're Making Lot Of Unplanned. Application And Also
Your Application Needs To Be Tested Immediately After Implementing These
Changes. In Such Cases Manual Testing Is Really Effective. Let's Move On To
Our Next Question Which Is What Are Disadvantages Of Manual Testing?
Apart From The Pros That Offers It Has A Lot Of Demerits As Well. First Of All,
It's Really Time Consuming. Manual Disk Cannot Be Reused Which Means
Every Time There's A Change In Your Application. The Tester Need To Run All
The Test Cases Again. Well This Is Rather Type Consuming Activity And That
Is Why Manual Testing Is Really Time Consuming. Then You Have Like Testing
Limitations. You Can't Go And Apply Manual Testing For Performing Load And
Performance Testing.

16th Assignment

Shin On Manual Testing Interview Questions Testing Is Really Crucial To

Success Of Any Software Product In This Competitive World. Through
Automation, Testing Is Raised These Days. Unfortunately, It Cannot Be
Applied In All The Scenarios. No Matter How Good Automated Tests Are, You
Cannot Automate Everything And That Is Why Manual Tests Play A Very
Important Role In Software Development. As Well As Testing In The Coming
Handy Whenever You Have A Case Where You Cannot Use Automation.
Hence, There's A Lot Of Demand For People With Skills Relevant To Manual
Testing. This Manual Testing Interview Question Session Is The Perfect Guide
For You To Master Manual Testing. So, Without Any Delay, Let's Go Ahead And
Take A Look At Today's Agenda. To Make It Much More Easier For You Guys To
Understand, I've Divided The Questions. And The Three Categories, Beginner
Level Manual Testing, Interview Questions, Advanced Level Questions. And
Lastly, We Have Real World Scenario Based Questions Which Are Based On
Manual Testing. So I Hope Agenda Was Clear To You Guys. But Before We
Actually Get Started, Please Do Not Forget To Subscribe At Eureka Youtube
Channel To Stay Updated With Current Trending Technologies. So Here We
Go. Let's Begin With The First Category Of Questions, Which Are Bigger Level
Questions. The First Question That We Have Here Is Very Basic. What Is
Software Testing? Explain In Simple Terms? Do You Guys Agree With Me When
I Say Every System Has Software Box? Well, It's True, Right? It's Impossible To
Design And Bring Out A Perfect Software Product. So Software Testing
Basically Is The Process Of Executing Any Sort Of Software Or An Application
To Find Out If There Are Any Bugs. There's Some Sort Of Errors In It, So
Before Actually Goes Public, Programmers Spend Hours Trying To Iron Out
Every Little Bug That They Check For. Any Mistakes And Problems In The
Design And The Functionality Of The Software. Well, Until That Product Won't
Be Available For Commercial Use In The Market. So As That Name Already
Suggests, Software Testing Means Checking The Develop Software For Any.
Dates And Problems And The Initial Design. Next Time We Have A Following
Question Which Says Why Software Testing Required And How Does Testing
Benefit An Organization. Software Testing Is Really A Mandatory Process
Which Guarantees That Software Product Is Safe And Good Enough To Be
Released To Market For Public To Use It Well, Here Are Some Compelling
Reasons To Provide. Listing Is Really Needed. First Of All, It Points Out The
Defects And Errors That Were Made During The Development Phase. So
Basically It Provides A Quality Assurance. It Reduces The Coding Cycles By
Identifying Issues At The Initial Stage Of Development Itself, It Ensures That
The Software Application Requires Lower Maintenance Costs And It Results In
More Accurate Consistent. And Very Reliable Results Testing Ensures That
Customer Finds The Organization More Reliable And Their Satisfaction In The
Application Is Maintained. Continuous Testing Also Make Sure That Software
Is Bug Free And The Quality Of The Product Meets The Market Status. And
Lastly, It Ensures That The Application Doesn't Result In Any Failures That
Could Be Of Some Harm To People Who Are Using It. So In This Way Software
Testing Is Really Required To Bring Out A High Quality And Safe Product To
Market. Going On To Next Question, We Have The What Are The Two Main
Categories Of Software Testing? Well, Software Testing Can Be Divided Into
Multiple Categories Based On Different Scenarios. But Mainly You Can Divide
Software Testing Into Two Types Which Is Manual Testing And Automation. So
Manual Testing Is Pretty Self-Explanatory, Which Is Testing Of A Web
Application Is Basically Done By Human Action. That Means Someone
Actually Goes On A Device To Evaluate Numerous Components Like Design,
Functionality And Performance Of The Application. But A Testing To Find
Defects Or Bugs Manually Is Really Time Consuming, Right? It's Expensive,
It's Often Repetitive And It's Subjective To Human Error. And That Is Why
Automation Testing Comes Into Picture. Automation Testing As Well
Automated. If I Have To Tell, Automation Testing Uses The Assistance Of
Tools, Scripts And Software To Perform Test Cases By Repeating Predefined
Actions. So These Are Two Main Categories Of Software Testing, Manual
Testing And Automation Test. Next Question That We Have Is What Exactly Is
Quality Control? There Are Different Terms That Are Associated With Quality.
When We Are Referring To Software, You Have Quality Control, Quality
Assurance And Many More. So What Exactly Is Quality Control? Quality
Control Is A Product Oriented Approach Of Running A Program To Check If It
Has Any Defects. The Key Point That You Can Remember Is. This Product
Oriented Approach So Using Quality Control Testers Make Sure That The
Software Meets All The Requirements Which Are Put Forth By Stakeholders
And End Users. It Includes Different Type Of Testings Like You Have Functional
Testing Like Unit Testing, Usability And Integration Testing. You Also Have Non
Functional Testing Like Compatibility, Security And Performance And All That.
So Quality Control In General Is A Product. Approach Of Running A Program To
Determine If It Has Any Defects Or Not. Going On To Our Next Question It
Says What Different Types Of Manual Testing Are There Well Basically You
Have Six Types Of Manual Testing Which Are Black Box Testing, White Box
Testing, Unit Testing, System Testing, Acceptance Testing And Integration
Testing. All Of These Types In Very Brief Manner But If You Want To Know More
You Can Actually. Go Ahead And The Photo Editing Or Youtube Playlist On
Software Testing. So What Exactly Is Black Box Testing And Black Box Testing
Testers Analyze The Functionality Of The Software Or An Application Without
Actually Knowing Much About The Internal Design Or Structure Of The
Application That They're Testing. Talking About White Box Testing And Light
Black Box Testing White Box Requires A Profound. Knowledge Of Code As It
Includes Testing With Some Structural Part Of The Application. Next Step You
Have Unit Testing. It's A Way Of Testing The Smallest Piece Of Code Which
Usually Referred To As A Unit. Then There's Integration Testing Where You
Test The Interface Between The Units. After That We Have System Testing
Which Is Done To Examine The Fully Working Of An Integrated Software
System Against The User Requirements. And Lastly. We Have UAT Or
Acceptance Testing. It's A Formal Testing That's Performed Based On User
Requirements And Function Processing. This Type Of Testing, That's
Acceptance Testing. It Covers End Users, Real-World Scenarios. So Yeah,
These Are 6 Typical Types Of Manual Testing. Moving On To The Next
Question, Explain The Difference Between Alpha Testing And Beta Testing.
When Both Alpha And Beta Testing Are Customer Validation Methodologies
On Top Of That, Both Of Our Acceptance Testing Types, They Help In Building
Confidence To Launch The Product In The Market And That's How They Result
In Success Of Product In The Market. So What Exactly Is Alpha Testing? Alpha
Testing Is Internal Acceptance Testing Which Is Performed To Identify All
Possible Issues And Bugs. Testing But Before Releasing The Software For Beta
Testing. So The Focus Of This Testing Is To Simulate Real Users By Using Black
Box And White Box Technique. The Key Point Is You Perform It After
Acceptance Testing But Before Actually Releasing The Product For Beta
Testing. Now Beta Testing Of A Product Is Performed By Real Users Of
Software Application In Real Environments. It Allows The Customer An
Opportunity To Provide Inputs To The Design Functionality. Or It Could Be
Usability Of A Product, Though Companies Like Do Liquors In-House Quality
Assurance With Dedicated Test Teams. It's Practically Impossible To Test An
Application For Each And Every Possible Combination Of Test Cases, Right?
And That Is Why Beta Releases Make It Much More Easier To Test The
Application On Thousands Of Test Machines And Fix The Issues Before
Actually Releasing The Product To Market An Alpha. Testing Is Performed
Before Being Arrested. So Yeah, That's The Difference Between Alpha And
Beta. I Hope The Difference Is Clear. Let's Move To Next Question. What Are
The Different Levels Of Manual Testing? So Be A Manual Testing Or
Automation Testing Or Software Testing In General, There Are Like 4 Levels.
First Up You Have Unit Testing, Then There's Integration Testing. After That
System Testing, And Lastly You Have Acceptance Testing. So Unit Testing Is A
Way Of Testing The Smallest Piece Of Code, Which Is Referred To As Unit. A
Unit Is Something That Can Be Logically Isolated In A System. It Can Be
Anything That You Want. It Can Be A Specific Piece Of Functionality Or It Can
Be A Program Or A Method In The Program, Anything. So The Main Focus
Here Is On The Functional Correctness Of The Standalone Modules Or Unit.
Next Up. Integration Testing. It's Performed After Unit Testing With Different
Units, Components And Modules Of Software Are Integrated Together. The
Focus Of Integration Testing Is To Check The Correctness Of Communication
Among All The Modules. So In Simple Terms You Can Say That You Are
Checking The Interface That's There Between The Different Units Or Modules.
After That The System Testing Is Carried Out. Complete Fully Integrated
Software Product To Evaluate The Behavior Of The System And Then To
Examine The Fully Working Of An Integrated Software Application According
To User Requirements. Under System Testing, We Have Different Techniques
Like Functionality Testing, Performance Testing, Scalability Testing, Load
Testing, Stress Testing, Regression Testing And Many More And The Last Level
That We Have Is UAB. For User Acceptance Testing Or In Simple Terms,
Acceptance Testing.

17th Assignment

Maximum Binary Heat Is For Every Node In A Heap. The Nodes Value Is
Greater Than Or Equal To Values Of A Children And Popular Applications Of
Binary Heap Include Implementing Efficient Priority Queues, Efficiently
Finding The Case. Elements In An Array And Many More. The Next Concept Is
Hash Tables. Imagine That You Have An Object And You Want To Assign A Key
To It. To Make Searching Very Easy To Store The Key Value Pair, You Can Use A
Simple Array Like A Data Structure Where Keys That Is Integers Can Be Used
Directly As An Index To Store Data Values. However, In Cases Where The
Keys. Are Too Large And Cannot Be Used Directly As An Index. A Technique
Called Hashing Is Used In Hashing. The Large Keys Are Converted Into Small
Keys By Using Hash Functions. The Values Are Then Stored In A Data
Structure Called A Hash Table. A Hash Table Is A Data Structure That
Implements A Dictionary ADP That Is A Structure That Can Map Unique Keys
To. In General, A Hash Table Has Two Components, One Bucket Array And The
Hash Function. A Bucket Array For A Hash Table Is An Array A Of Size N,
Where Each Cell Of A Is Thought Of As A Bucket That Is The Collection Of Key
Value Pairs. The Integer N Defines The Capacity Of The Array Next Hash
Function. It Is Any Function That Maps Each KK In Our Map To An Integer In
The Range 0 N One, Where North Is The Capacity Of The Bucket Array For
The Table. When We Put Objects Into A Hash Table, It Is Possible That
Different Objects Might Have The Same Hash Code And This Concept Is
Called As Collision. Could Deal With The Collision. There Are Techniques Like
Chaining And Open Addressing. So These Are Some Of The Most Basics And
Frequently Used Data Structures In Java. Now That You Are Aware Of These,
You Can Start Implementing Them In Your Java Programs. So I Hope You
Understood The Concept Of Linear And Hierarchical The Structures. What Is
Linkless? A Linked List Is Considered As A Data Structure Similar To Any Other
Data Structure Like Arrays, Stacks And Queues. The Link List Have Three
Major Parts, Head, Tail And Node. Every Node In The Linked List Is
Interconnected Using The Address Of The Next Node. Before We Get Started
With The Link List, Let Us Understand The Terminology Of Harry. Before Using
An Addy, We Actually Reserve The Memory Blocks In The Memory To Store
The Data In Order To Process Them. For Example, I Have Reserved An Array
Of Integer Data Type And I'll Be Storing 5 Elements In The Vector. The Name
Of My Array Is My Array And The Addresses For The Array Are 0123 And Four.
So Now Let Us Try To Add The Elements Into My Array. The 1st Element Is. As
You Can See, The 1st Element Is Stored In The Index Zero Of My Array.
Similarly, I'll Try To Add Four More Elements Into My Array Which Are 203040
And 50. As You Can See, The Data Has Been Successfully Inserted And The
Insertion Order Has Been Secured. Each And Every Element Has Been
Inserted Into The Array In A Sequential Order And Now We Can Access Them
Using Their Index Numbers. But In Case Of Link List This Doesn't Happen.
Unlike Arrays, They Do Not Work With The Completely Reserved Sequential
Collection Of Memory. Instead They Choose The Random Blocks From The
Heap And Store The Data Into It And Provide Access To The Data Whenever
Needed. The Best Part Is Once The Use Of Linked List Is Done And If You
Won't Need It, Then You Can Actually Dump The Memory Blocks Back Into
The Memory Which Makes Them Reusable. Once You Provide The Data Into
The Linked List, It Will Part Of The Particular Number Of Memory Blocks From
The Heap Based On The Data Type You Provide. For Example, Two Or Four
Bytes For Each Block Of An Integer Data Type, And Four Bytes For Each Block
Of A Float Data Type, And 16 Bytes Of Data For Each Block Of Double Data
Type, And So On. Each Block It Selects Will Have A Memory Address Along
With It And A Space For Data To Be Stored. Once The Data Is Stored, Then
The Last Memory Block Will Replace The Address With A Null Value Which
Indicates The End Of The Linked List Using The Interconnection Between The
Nodes. The Linked List Page Like An Array And Displays All The Data In The
Form Of A Sequence. Now That You Have Understood What Exactly A Linked
List Is, Let Us Discuss About The Types Of Linked List. The Linked Lists Are
Majorly Divided Into Three Types, The Singly Linked List, The Doubly Linked
List And The Circular Linked List. A Singly Linked List Is A Standard Linked List
Which Mainly Consists Of Two Fields, The Address Space To Store The Address
Of The Next Node And The Block For Storing The Data. As You Can See, This
Particular Node Is The Head Node And This Particular Node Is The Tail Node.
This Is The Plot Which Stores The Address Of The Upcoming Node And This
Block Stores The Data. We Can Traverse In One Single Direction In A Singly
Linked List. And These Nodes Are The Intermediate Nodes Which Are Lying In
Between The Head Node And The Tail Node. As You Can See This Particular
Block Of This Node Is Pointing To Its Previous Node And This Particular Block
Of This Node Is Pointing To The Upcoming Node. And This Particular Block Is
Designed To Store The Data Which You Provide Into It. This Makes It Doubly
Linklist Traverse In Both Directions. Now Let Us Move Into Circular Linked List.
A Circular Linked List That's What It Makes As A Circular Link List. Now Let Us
Discuss Some Important Features Of Linked List. The Important Features Of
Linked List Are First One Is Q&Q Interface. The Link List Implements Queue
And Deque Interface. Therefore It Can Also Be Used As A QQQ Or A Stack.
The Next One Is It Can Contain All The Elements Including Duplicates And
Null. The Third One Is Linked List Maintain Insertion Order Of Elements. The
Next One Is Java Linked List Is Not Synchronized. That Means In The
Multithreaded Environment You Must Synchronize Concurrent Modifications
To The Link List. Externally We Can Use Collections Dot Synchronized List To
Get Synchronized Linked List. Linked List Class Does Not Implement A
Random Access Interface, So We Can Access Elements In A Sequential Order.
We Can Use List Iterator To Iterate The Elements Through The List. Now That
We Have Understood The Features Of The Linked List, Let Us Move Into The
Methods That We Can Use In The Linked List. There Are More Than 40
Methods That We Can Apply And Link List. But Here To Save Time Let Us
Discuss The Crucial Methods Required To Actually Work With Linked List. Here
As You Can See I've Used The Linked List Method Which Is Provided In Java
And I'm Creating A Linked List And Then I'm Trying To Add The String Type
Values Into My Linked List Using The Link Dot Add Method. And Finally We
Shall Also Use Collection Method Which Is Previously Described In Java To Add
Few More Elements Which Are Of String Type Into Our Linked List And Try To
Append Them In The Tail Section Of The Linked List. Let Us Try To Execute
This Program And See How Does It Work. Stop Output Has Been Printed Here.
The First Data Which We Tried To Insert Into A Linked List Was Welcome To
Edureka, And After That We Tried To Append The Data Of String Type Into The
End Part Of Our Linked List, Which Happens To Be The Tail And The Link List.
After Appending The String Data Type At The Last Is Welcome To Eddie Reka,
An Online Technology Training Center. Now Let Us Try To Insert The Data At
The Head Part Of The Linked List. So In This Particular Program I'm Making
Use Of The Linked List Method Which Is Previously Described In Java And I'm
Adding The Elements Of Welcome And Edureka Which Are String Data Type
Into The Linked List. And In The Next Section I'm Using Collection Method
And I'm Adding Few More Elements Into The Linked List At The Head Section
Of The Linked List. Now Let Us Try To Execute This Program And See. How
Does It Work? As You Can See, The Output Has Been Successfully Generated
And The Date Of The Linked List Before Appending The Data To The Head
Section Was Welcome At Eureka. And After Appending The Data To The Head
Section, We Have Welcome To The Most Popular Online Technology Training
Center At Eureka. Now Let Us Execute Add Method. In This Particular Method,
We Are Just Appending New Elements Into The Linked List Similar To The
Previous Methods. I Have Created A Linked List Using The Linked List Method
Which Is Previously Programmed In Java And I'm Trying To Add Up The
Elements Into It. As You Can See In This First Section, I'm Having Few
Elements Called Hello World Message From. And After That In The Second
Section I'm Trying To Add 2 New Elements Which Are New And Element. Let
Us Try To Execute This Program And See How Does It Work. As You Can See
The Output Has Been Successfully Generated And The Linked List Before
Appending The New Element To It Is Hello World Message From Edureka And
After Appending The New Element We Have Hello World Message From
Edureka And The New Elements Which Are New And Element. Now Let Us Try
To Append The Data Using Add Method By Using The Index Followed In The
Linked List. As You Can See In This Particular Example, I'm Trying To Add 2
New Elements Which Are U And Welcome At The Index Locations Two And
Four Respectively. Now Let Us Try To Execute This Program And See How
Does It Work.

18th Assignment

See To Check The Performance Of An Application Using Manual Testing. You

Require A Lot Of Users And Gadgets, Which Again Increases The Cost Of The
Testing. So It's Better To Go For Automation In That Case. And Obviously,
Since Manual Testing Is Performed By Humans, There's Always This Possibility
Of Errors. The Testing Results Will Be As Good As The Tester Performs The
Test That Set. You Can't Guarantee The Quality With Manual Testing. There
Are Chances That The Tester May Miss Out The Same Box On Re- Testing The
Application Because It's Being Performed By Human. There's Always
Possibility Of That Human Making An Error. So Yeah, These Are Certain
Disadvantages Of Manual Testing. Moving On. The Next Question Is, Is
Documentation Really Necessary In Manual Testing? Yes, Documentation
Craig A Critical Role In Achieving Effective Software Testing. Well, Details Like
Your Designs, Business Rules, Requirements, Specifications, Inspection
Reports, Configurations, Code Changes, Test Plans, Bug Reports, Et Cetera All
Should Be Documented. Documenting The Test Cases Will Facilitate You To
Estimate The Testing Efforts That You Will Need. Along With Your Test
Coverage, It Will Help You To Track And Trace Your Requirements As Well.
Some Commonly Applied Or Used Documentation Artifacts That Are
Associated With Manual Testing Or We Did Discuss One Earlier, Which Is Test
Case. After That, We Have Test Plans, Test Scenario, Traceability Matrix And
Many More. Well Guys, With This, We've Completed The Basic Level
Questions. So Let's Move On To Next Level, Which Is Advanced Level Manual
Testing Interview Questions. So Let's See What's The First Question And
Advanced Level Category. So What's The Difference Between Manual Testing
And Automation Testing? You Guys All Know The Basic Difference. While
Manual Testing Is Literally Performed By Humans Or Human Action. Whereas
Automation Testing Is Performed By Human But With Assistance Of Tools,
Scripts And Other Things. That Being The Main Difference, Let's Go Ahead
And Discuss Other Differences As Well. So Manual Testing Since It's
Performed By Humans, The Accuracy And Reliability Of Test Cases Are Low
Where As Automation Testing On Other Hand Is Performed With Tools And
Skips. The Reliability And Accuracy Is Literally High. The Time Required For
Manual Testing Is Literally High As Human Resource Perform All The Task.
What Is Time Required For Automation Testing Is Comparatively Low As
Software Tools Execute The Test Cases. In Manual Testing, The Initial
Investment Which You Make Is Slow Because You Don't Use Any Kind Of Tools
And All That Here. But The Writing Of Investment Is Low As Well. But As An
Automation Testing, Initial Investment Is Literally High. Got You Written Of
Investments Is Also High. Manual Testing Is Performed When You Have Test
Cases That Need To Be Learned Only Once Or Twice. Also When You Have
Test Cases Suitable For Exploratory Testing, Usability Testing Or Ad Hoc
Testing, You Can Use Automation For Performing Regression Testing,
Performance Testing, Load Testing Or When You Have Cases That Need To Be
Tested Multiple Times Now, One Best Thing About Manual Testing Is That It
Allows For Human Observation To Find Out If There Are Any Glitches And
That's Why Manual Testing Helps In Improving The Customer Experience.
When It Comes To Automation Testing, There's No Human Observation
Involved And That Is Why It Doesn't Guarantee The Positive Customer
Experience That Manual Testing Guarantees. So These Are Certain Basic Key
Differences Between Manual Testing And Automation Testing. Now Let's Move
On To Our Next Question. When Should You Oft For Manual Testing Over
Automation Testing? There Are Certain Key Cases Or Scenarios When Manual
Testing Should Be Before, For Example, When You Have Short Time Projects.
Automated Tests Are Aimed At Saving Time And Resources, And Yet They
Take A Lot Of Time And Resources To Design Maintain That For Example, If
You Are Building The Small Promotional Website, It Can Be Much More
Efficient To Rely On Manual Testing Rather Than Go Ahead And Create All
Those Automated Test Cases While It Takes Time, Right? So In Such Cases
When You're Working On Small Scale Projects Or Projects Which Take Small
Amount Of Time, You Could Go For Manual Testing. Also When You Have Ad
Hoc Testing. In Ad Hoc Testing, There's No Specific. Approach. And There's No
Fixed Approach. It's A Totally Unplanned Method Of Testing Where The
Understanding And The Inside Of The Tester Is The Only Important Factor.
Well, Again, Manual Testing Sounds Good. Then There's The Case Of
Exploratory Testing Even Then, Manual Testing Is Preferred Because In
Exploratory Testing It Requires To Choose Knowledge, Experience, Skills,
Analytical Skills, Creativity And Mainly Intuition. So Human Involvement Is
Really Important Here. Lastly, You Have Usability Testing. So When
Performing Usability Testing, Go Ahead And Use Manual Testing. So When
Performing Usability Testing, Usually The Tester Needs To Measure How User-
Friendly, Efficient Or Convenient The Software The Product Needs To End
User. So You Should Think In Terms Of End User For That Again, Manual
Testing Is Preferred. So These Are Certain Scenarios Where You Can Prefer
Manual Testing Over Automation Testing. The Next Question That We Have Is
What Are The Phases Involved In Software Testing Life Cycle? Well, It's Quite
Simple. It Begins With Requirement Analysis Where You Figure Out Or
Categorize The User Requirements. Next Up, Based On The Requirements
That You've Gathered, You Plan Your Entire Test Lifecycle. Once You're Sure As
To What You're Performing Testing On, Which Type Of Testing You Have To
Perform In All That, You Start Developing Your Test Cases. Then Set Up The
Entire Test Environment Which Will Make Your Testing More Effective. After
That You Can Start Your Test Execution. And Lastly You Have Test Cycle
Closure. So Let Me Repeat It Again. You Begin By Analyzing The
Requirements Put Forth By The End User. Then You Start Planning Your Entire
This Cycle. Then You Develop Your Test Cases, Categorize Them, Design Your
Test Environment After That Basically You Design On Different Kind Of Test
That You Wanna Perform. What Do You Want To Test On And All That? Then
You Execute The Test Cases That You've Created And Lastly, Then There's Just
Cycle Closure, Which Indicates The End Of Your Testing Cycle. Next Question
That We Have Is A Really Interesting One. What's The Difference Between A
Bug Or Defect And An Arrow? We Did Already Discuss The Difference
Between A Bug And A Defect. Let Me Go Through It Again. So Defect Is A
Variance Or Difference Between Expected Results And Actual Result.
Detected By The Developer After The Product Goes Live. So Defect Is An
Error Which Is Found After The Application Goes Into Production. In Simple
Terms, It Refers To Several Troubles With The Software Product, With Its
External Behavior Or With Its Internal Features. Next Up, This Bug. It's A
Folding Software That's Detected During Test Time. They've Come Mainly
Because Of Some Coding Error Which Might Lead To The Entire
Malfunctioning Of A Program, They May Also Lead To A Functional Issue In
The Product. So Basically Bug Or Fatal Errors That Could Block A Functionality
Or Result In A Crash Or Cause Performance Bottleneck. Now What Exactly Is
Error? Error Is A Mystique, Misunderstanding Or Misconception On Part Of
Software Developer. So When I Say Software Developer It Includes Software
Engineers, Programmers And Less Testers Whoever Is In Contact With The
Software. So For Example, A Developer May Misunderstand Or Design
Addition, Or A Programmer Might Just Type A Wrong Variable Name Which
Might Lead To An Error. Error Normally Arises In Software And It Leads To
Change The Functionality Of The Program. So That's The Difference Between
A Bug Or Defect And An Error. Moving On To The Next Question, What
Actually Makes A Good Test Engineer ? First Of All, A Good Engineer Should
Have A Test To Break Attitude. That's An Ability To Take The Point Of View Of
A Customer. You Should Have A Strong Desire For Quality And Keen Attention
To Detail. Also Tact And Diplomacy Are Also Needed, Which Is To Maintain A
Cooperative Relation With The Rest Of The Developers That Is Involved To It.
And Obviously It Should Have An Ability To Communicate With Both Technical
People, Non-Technical People As Well. So You Should Have Excellent
Communication Skills And You Should Have Ability To Judge The Situations
And Make Important Decisions To Test High Risk Areas Of An Application
When The Time Is Actually Very Limited. Along With All This, It's Always Best
To Have An Experience In Software Development Or Testing Field Because
Previous Experience Can Be Helpful As It Provides A Deeper Understanding
Of Software Development Process. And It Just The Test Was An Appreciation
For The Developers Point Of View. So These Are Certain Qualities That You
Look For When You're Hiring A Good Test Engineer. Moving On To Our Next
Question, What Is Regression Testing And When To Apply It? Regression Test
Is Basically A System Wide Test Whose Main Purpose Is To Ensure That Small
Change In One Part Of The System Doesn't Break The Existing Functionality.
Else Where In The System. So If You Consider Regression Testing As An
Unintended Change, Then This Type Of Testing Is The Process Of Funding For
Those Changes. So In Simple Terms, It's All About Making Sure That Your Old
Bugs Doesn't Come Back To Haunt You. Let's Take A Look At Fictitious
Example That Illustrates The Concept. So When Adding A New Payment Type
To Shopping Website, You Have To Rerun The Old Test To Ensure That New
Code Hasn't Created Any New Defects Or It Hasn't Introduced Or
Reintroduced Any Old Ones. So Regression Testing Is Really Important
Because Without It It's Quite Possible To Introduce Intended Fixes Into System
That Create More Problems That They Can Actually Solve. So How Do You
Actually Apply Regression Testing? It's Quite Simple. You Have Tested
Software, But You'll Have To Add A New Feature. So A Feature Has Been
Updated. Now You Want To Check If The New Feature Is Affected Or Brought
Out Any Old Bugs Or If It Has Introduced Any New Bugs. For That You Perform
Regression Testing. All You Have To Do Is Create The Regression Test Plan Just
Like How We Perform The Entire Software Testing Lifecycle You Carried On
And You'll Have Newly Tested Software With Updated Feature. Well, That's
Regression Testing. The Next Question That We Have Is What's The
Difference Between System Testing And Integration Testing? It's Quite
Simple. System Testing It Tests The Entire Software Application To See If The
System Is Compliant With User Requirements And Stakeholders
Requirements. But Integration Testing It Tests The Interface Between The
Modules Or Units Of Software Application. System Testing It Involves Both
Functional And Non Functional Testing, Like Insanity Usability Testing,
Performance Testing, Load Testing And All That. Whereas Only Functional
Testing Is Performed In Integration Level Or Integration Testing To Check If
Two Modules When Combined Give The Right Outcome Or If They Are Able To
Communicate Properly Through The Interface Or Not. Well System Testing Is
High Level Testing Which Is Performed After Integration Testing Where As
Integration Testing Is A Low Level Testing Which Is Performed After Unit
Testing.

19th Assignment

Motion Along A Straight Line, That Is, Motion Is Straight Lines Go Ahead With
The Exercise Practice. First Question Man Walks At A Speed Of Six Kilometer
Per Hour For One Kilometer And Eight Kilometer Per Hour For The Next One
Kilometer. What Does Average Speed For The Walk Of Two Kilometer? Now
It's The Distance Has Been Given, We Do Know About The Time, What Time
He Has Taken For His Overall Journey. So Let Me Write Down The Total
Distance Travelers And Let Me Write Down The Time Taken First Of All In
Total, He Would Have Travelled That Will Be Two Kilometer Because One
Kilometer Here Start With Six Meter Per Hour, Next One Kilometer Here Start
With Eight Meter Per Hour. The Total Distance Traveled Will Come Out To Be
Two Kilometer. Now Time Taken For First Kilometer Time Taken Let Me Call
That For First Kilometers T One That Will Be Equal To Distance Upon Speed
One Upon Six R. For The Next One Kilometer, The Time Will Be One Upon
Eight I'm Not Writing The Complete Elaborating Statement. I Hope That You
Can Get From What I'm Talking About. T One Is The For First Kilometer Time
Taken Is One By Six T Two Will Be One By Eight Of An Hour. Now Average
Speed For Its Overall Journey. See What It Will Come Out To Be. Total Distance
Upon Total Time. Two / One By Six + One By Eight. I Believe That Now You
Can Easily Solve This. Two / One By Six + One By Eight. See What Will Come
Out To Be. If We Take LCM Of Eight And Six As Twenty Four, We'll Be Getting
Six Into Four, Four + Three / Twenty Four, And Here We Have Two. Let's Take
That Twenty Four In The Numerator Will Be Having Twenty Four Into Two /
Seven, So This Will Be Forty Eight By Seven Kilometer Per Hour. That Is, This
Is Approximately Equal To Seven Kilometer Per Hour. So From Here If You
Check The Option Which Is Best Fitting, Which Is Best Matching, That Is
Nearly Equal To Seven Kilometer Per Hour. I Hope That You Have Got How We
Have Solved This Question. We Have To Evaluate What Is The Time Taken
Between One By Six For First Kilometer And One By Eight For The Next
Kilometer And Then Total Distance Is Two Kilometers. So Divide Two Divided
By The Entire Time Taken. So We Are Getting This As The Answer That Is
Forty Eight By Seven That's Nearly Equal To Seven Kilometer Per Hour. That's
Why I Have Mark Seven Kilometer Per Hour As The Answer. Let's Go Ahead
With The Next Problem. And Let Me Clear The Board Hope That You
Understood This Question, The Next Question. A Particle Starts From Rest.
That Means His Initial Speed Is Zero Particle, Its Initial Speed Is Zero Starts
From Rest. With A Constant Acceleration Like That Accent Be A At The Time T
Second. Again The Speed Is Found To Be Hundred Meter Per Second And
Once Again Later This Speed Becomes One Fifty Meter Per Second. Find The
Acceleration. Constant Acceleration Starts From Rest. So Can We Use V
Equals To U + Eighty? We Can Use This V Is Given As One Fifty. You Will Be
Taken As Hundred A That Is Constant As A And Time Keep It As One. So A Will
Come Out To Be Fifty Meter Per Square Second. Easy Question. Sometimes
We Get Such An Easy Question That Directly You Can Get The Answer. So
Your Answer Will Be Fifty Meter Per Square Second. I Hope That You
Understood This Question We Have To Simply Use The Equation Of Motion We
Go V + Eighty And You Will Get The Desired Result. Not Commenting More On
This. Let's Go Ahead With The Next Problem Of The Session. That Is The Third
Problem We Have. A Train Hundred Meter Long Is Moving With A Velocity Of
Seventy Two Kilometer Per Hour. Find The Time It Takes To Cross The Bridge
One Kilometer Long. So Let Me Show You The Scenario Of What Is Happening.
We Have A One Kilometer Long Meter Long Bridge, So Let Me Draw A Bridge.
Let Me Tell You, This Is The Bridge That The Train Has To Travel. Now Let's Say
The Train Is Moving And It's Approaching Towards The Bridge. In This Way It Is
One Hundred Meter Long, One Hundred Meter Long The Train Is. Let's Say
This Is The Train. Now The Train Length Is Hundred Meter. That Is Point One
Of Kilometer. And The Entire Bridge Is One Kilometer. Understand Now As
This Front End Observe This Front End As This Front End Reaches Here It
Would Have Travelled One Kilometer But It Has To Cross The Bridge. So It Will
Further Travel Its Own Length That Is Hundred Meter To Cross The Bridge. So
In Total The Train Would Have Traversed This Much Distance, That Is One .
One Kilometer. Now That Is One . One Kilometer Is Traveling With The Speed
Of Seventy Two Kilometer Per Hour. So Time Taken Will Be Distanced Upon
Speed. One . One / Seventy Two Kilometer Per Hour. You'll Get This In R The
Options Are Given In Seconds, So Let Us Convert Into Seconds. So What You
Do, Multiply With Sixty, You Get In Minutes. Multiply With Sixty You Will Get In
Seconds. If You Calculate This, You'll Get It This Approximately Equal To Fifty
Five Seconds. This Will Be The Answer. If You Calculate You're Going To Obtain
Fifty Five Second As The Answer. The Answer Will Be Fifty Five Seconds To
Cross The Bridge. That's How You Have To Approach Such Kind Of Question.
You Have To Check That The Entire Essence Travels Will Be One . One
Kilometer And Not Only One Kilometer. The Next One Forth A Car Travels
Along A Straight Line For First Half Time. For First Half Time It Is Travelling
With Along Straight Line With The Speed Of Forty Kilometers Per Hour And
The Second Half Time With The Speed Of Sixty Kilometer Per Hour. Find The
Average Speed Of The Car Option A Forty Five B Fifty C Fifty Five D Sixty.
Everyone Every Each One Of The Option Is In Kilometer Per Hour. Now You
See Here. For The First Half Time And For The Next Half Time This Speed Has
Been Given, You Have To Find Out The Average Speed. See, Let's Say This Is
The Journey Of The Entire Car. From A To B. We Don't Know The Distance,
How Much Distance They Have Traveled. Now See For First Half Time Let's
Say Time T Has Taken. So It Would Have Moved A Distance Off Forty T. for
The Next Half Time It Would Have Moved A Distance Off Sixty D Because It's
Being Your Time Is The Distance, So Net Distance. That It Would Have
Traversed. That Will Be Forty T + Sixty T. That Will Come Out To Be Hundred T
Forty T + Sixty T That Will Be In Kilometers Also That Will Get As Hundred T
You Got Net Distance, You Got Total Time. That Is Two T. Total Time That Is
Equal To Two T. Now I've Average Speed This Is What We Are Looking For
Total Distance Upon Total Time Hundred T / Two T You'll Get This As Fifty
Kilometer Per Hour. Fifty Kilometer Per Hour. This Will Be The Required
Answer Fifty Kilometer Per Hour. So The Right Answer Will Be Option Will B
That Is Fifty Kilometer Per Hour. Next Question Without Taking More Time,
Let's Solve The Next Question. A Motorcycle Is. First Of All, Let Me Wipe This.
This Might Not Be The Right Answer. Motorcyclist Goes From Station A To B At
Forty Kilometer Per Hour And Then Returns From B To A At One Twenty
Kilometer Per Hour. Calculate The Average Speed. The Distance Is Same In
Both The Cases. Speed Is Different. You Might Be Thinking That One Twenty +
Forty One Sixty / Two You Get Eighty More Per Hour. Let's Check Whether The
Average Is Correct Or Wrong. Let's Check That We Will Learn Something With
This Question. Again, From A To B Two Different Speeds. Let's Say This Is His
Journey Path. A To B While Moving From A To B, He Travels With Forty
Kilometer Per Hour. And While Returning From B To A, It Travels With The
Speed Of One Twenty Kilometer Per Hour. Let's Check What Is His Average
Speed. Let's Say The Separation Between The Two Is X. So Overall One
Moving On A to B And B To A The Total Distance Travel B Two X. So Total
Distance In Two And Four Journey Will Be Two X. Let's Talk About The Time
Taken To Move From A To B. Time T One That Will Be Distance Upon Speed X
Upon Forty. Time T Two For Returning From B To A. Distance Upon Speed.
Let's Go Ahead And Let's Write Down The Average Speed Formula. That Will
Turn Out To Be Average Speed Is Equal To Total Distance Two X Divided By
Total Time. Let's Put Up The Values Two X T One X By Forty. T Two Is X By One
Twenty. X And X Will Be Cancelled Out. We'll Be Left With Forty And One
Twenty. Now See Forty And One Twenty The LCM You Can Think About. LCM
Would Be One Twenty, And Let Me Put Here LCM As One Twenty. So Two /
Three + One One Twenty This Will Come Out With Four Upon One Twenty. So
This Will Come Out To Be Four Upon One Twenty That Will Give You Thirty
Thirty Into Two Will Give You Sixty Kilometer Per Hour. So The Right Answer Is
Sixty Kilometer Per Hour. This Is How You Have To Choose Three + One Four
Four Upon One Twenty Will Give You One / Four Four Upon One Twenty Will
Give You One Upon Thirty Thirty Into Two, You'll Get Sixty Meters Per Hour. So
The Right Answer Is Not Eighty, Rather It Is Sixty Kilometer Per Hour. Hope
That You Understood That Don't Take The Average So All Step Wise So All
What The Time Taken How I This Is Traveling What Is Total Distance What Is
Total Time Then You So All And Then You Leave Can Do Such Of Question
Never Take It Average For Equal Distance.
 20th Assignment

The Next Question Is Also Some What Similar To That. What Is White Box
Testing And What Are Various Techniques? White Box Testing Is Also Known
As Structure Based Testing. It Requires A Profound Knowledge Of Code As It
Includes Testing Of Some Internal Structures As Part Of Application. So Unlike
Black Box Testing, In White Box Testing The Tester Need To Have Some Sort
Of Knowledge Regarding The Internal Architecture Of The Application That Is
Testing. The Pump Is If You Ask Is To Enhance The Security, Check The Flow
Of Input Output Through Application To Improve The Design, Usability And All
That. Various Techniques That Come Under White Box Testing Are You Have
Decision Coverage, Statement Coverage, Condition Coverage, Multiple
Condition Coverage And Many Others. Another Question Based On The Same
Concept Is What Our Experience Based Testing Techniques. Experience Based
Testing Is All About Discovery, Invention, Intuition And It's All About Learning.
So The Tested Constantly Studies And Analyzes The Product And Accordingly
Applies A Skills, Traits, Experience To Develop A Test Strategy And Design
Test Cases. So Various Techniques That Come Under This Category Are
Exploratory Testing And Arrogance. The Next Question That We Have Is
What's The Difference Between Top Down And Bottom Up Approach? Well,
It's All There In The Name Of The Term Itself. In Top Down Approach, Testing
Happens From Top To Bottom, That's High Level Modules Are Tested First And
After That Low Level Modules. And Lastly Low Level Modules Are
Incorporated Into A High Level State To Guarantee That Framework Is
Working As It's Supposed To. Similarly, Bottom Up Approach Testing Happens
From Base Levels To Higher Levels. The Lowest Level Modules Are Tested First
And After That High Level Modules And Lastly High Level Modules Are
Incorporated To Low Level State To See If The Framework Is Working As
Expected Or Not Moving On We Have What's The Difference Between Smoke
Testing And Sanity Testing It's Quite Simple The Concept Of Smoke Testing
And Sanity Testing Is Very Similar Except Smoke Test Or Executed On Initial
Bills Of Software Product What Is Sanity Testing Our Tests Which Are Done On
The Bills That Have Cost, Smoke Test And Other Rounds Of Regression Test.
So What's The Motive Of Smoke Testing? It's To Measure The Stability Of
Newly Created Built So That It Can Go For More Rigorous Rounds Of Testing.
What's The Motive Of Sanity Testing? That's Evaluate Rationality And
Originality Of The Functionalities Of Software Bits. Another Main Difference Is
That Smoke Testing Involves A Lot Of Documentation And Scripting. Where
As Sanity Testing Doesn't Emphasize Any Sort Of Documentation. Smoke
Testing Is A Shallow And Wide Approach To Include All Major Functionalities
Without Actually Going Much Deep. Where As Sanity Testing Is Narrow And
Deep Approach And It Involves Detailed Testing Of Functionalities And
Features. Smoke Testing Is Executed By Developers. As Well As Testers
Sometimes When A Sanity Testing Is Executed Only By Testers. We Have
Another Difference Based Question Which Is The Difference Between Static
Testing And Dynamic Testing. So Static Testing Is White Box Testing
Technique. It Includes The Process Of Exploring The Records Of Documents To
Recognize The Imperfections In Early Stages Of Software Development
Lifecycle. The Key Point Is Static Testing Is Performed In The Early Stages Of
Development Life Cycle To Recognize Imperfections. Dynamic Testing It
Includes A Lot Of Execution Of Code And It's Done At Later Stage Of Software
Development Lifecycle. It Validates And It Approves The Output With
Expected Results. Static Testing Is Usually Implemented At Verification Stage.
So That's Early Stages. What Is Dynamic Testing Usually Starts During
Validation Stage. Static Testing Is Performed Before The Code Deployment
And Dynamic Testing Is Performed After The Code Deployment. Another
Important Thing Is Co Dealer Detection And Execution Of Program Is Not
Much Of A Concern When It Comes To Static Testing. Where As Execution Of
Code Is Really Necessary When You're Performing Dynamic Testing. So These
Are Some Key Differences Between Static Testing And Dynamic Testing. So
Guys, With This We Have Come To The End Of Advanced Level Questions Or
You Can Say Theory Based Questions. Now Let's Go Ahead And Deal With
Some Real Bold Scenario Based Questions. So The First Question That We
Have Under This Category Is How Will You Actually Go Ahead And Determine
When To Actually Stop Testing? Deciding When To Stop Testing Can Be Really
Difficult. Many Modern Software Applications Are So Complex And They Run
In Such Interdependent Environment That Complete Testing Can Never Be
Done. You Agree With Me There, Right? So Some Common Factors That You
Can Consider When You're Facing Difficulty To Decide On When To Stop Your
Testing Are That You Can Go Ahead And Consider The Deadlines Which Are
Released Deadlines, Testing Deadlines And All Those. And Suppose If You
Have These Cases Which Are Completed With Certain Past Percentage, Then
Maybe You Can Go Ahead And Stop Testing After You Think That They Want
Of Past Percentages Enough Or When Your Test Purchase Is Completely
Depleted. Well, Again, That's Another Reason To Stop Testing. Or When
Coverage Of Code Or Functionality Or Any Other Requirements Reaches A
Specific Point Or When You're Bug Grade Falls Below A Certain Level That You
Can No Longer Proceed With Testing. Or When Your Beta Or Alpha Testing
Period Actually Ends Well. These Are Certain Simple Ideas That Can Help You
Decide When To Stop Testing. Moving On To Next Question, What If The
Software Is So Buggy That It Cannot Be Tested At All? Often Testers
Encounter A Bug That Cannot Be Resolved At All. In Such Situations, The Best
Thing Is For Testers To Go Through The Process Of Reporting Whatever Bugs
They Find And Focus Mainly On Critical Parts. Well Since This Type Of Problem
Can Cause Other Issues Like Insufficient Unit Testing Or Insufficient
Integration Testing, Poor Design Of The Application, Improper Build Or
Release Procedures, Et Cetera. The Higher Authorities Or Managers Should
Be Notified And They Should Be Provided With Some Sort Of Documentation.
As A Proof Or Evidence Of The Problem Saying That So And So Bug Is
Common, And We Are Facing An Issue Where We're Not Able To Solve This
Bug At All. So In That Way, They Should Provide Some Sort Of Documentation
As An Evidence Of Proof To Their Higher Authorities Saying That Bug Is Really
Not Testable At All. Moving On To The Next Question, How You Actually Test A
Product? If The Requirements Are Yet To Freeze, It's Possible That A
Requirement Stack Is Not Exactly Or Not Available For A Piece Of Product
Sometimes. It Might Take Serious Effort To Decide If An Application Has
Significant Unexpected Functionality And Obviously It Would Indicate Deeper
Problems In Software Development Process. So What Do You Do In Such
Situations? So If The Functionality For This For Which Requirements Are Not
There Isn't Necessary For Functioning Of Your Application, Maybe You Can
Actually Remove That Functionality. Well, If You Think That Functionality Is
Really Necessary, Then Go Ahead, Create A Test Plan Based On The
Assumptions That You Have Made About The Product. But Again, Make Sure
That All The Assumption That You Made You Get It Right And There Well
Documented In The Test Plan. Moving On To Next Question, What If An
Organization Is Growing So Fast That Fixed Testing Procedures Are
Impossible? What You Doing Such Situations? Well, This Is A Very Common
Problem Which Is Faced In Software Industry, Especially Considering The New
Technologies That Are Being Incorporated And Some That Are Being Popped
Up Every Now And Then. So There's No Easy Situation Or Solution For The
Scenario, You Can Actually Go Ahead And I Very Skilled And Good People To
Deal With The Situation Or Management Should Actually Ruthlessly Prioritize
Quality Issues And Their Main Focus Should Be Put On Customer And
Everyone In The Organization Should Be Clear On What Actually Quality
Means To Them. So These Are Certain Solutions That They Can Adopt In
Situation Where They Actually Think That The Fixed Testing Procedures Are
No Longer Plausible Or Can Be Applied. Next Question That We Have Is How
Do You Know That The Code Has Actually Met The Specifications? So When I
Say A Good Code, It Doesn't Have Any Particular Definition. In Simple Terms,
Good Code Is Code That Works, That's Bug Free, It's Readable And Highly
Maintainable. So Most Organizations Have Their Own Coding Standard That
All The Developers And Testers Are Supposed To Stick To, But Everyone Has
Different Ideas About What's Best, What's Too Many Tools And What's Very
Few Rules, So There's No Fixed Thing As Good Code Or Anything. Well,
Honestly, There Are A Lot Of Tools These Days That Can Help You Check If
Your Code Is Sustainable, If It's Good Or If It Is Met Specifications. For
Example, You Have Something Called Traceability Matrix Which Ensures That
All Your Requirements Are Mapped To The Test Cases And When The
Execution Of All The Test Cases Finishes With Success, It Indicates That The
Core Is Met Your Requirement. You Can Go Ahead And Use Such Tools To See
If Your Code Is Met The Specifications Or Not. Let's Move On To A Next
Question So What Are Certain Cases Where You Consider To Choose
Automated Testing Over Manual Testing? Automated Testing Can Be
Considered Over Manual Testing During Multiple Situations, For Example
When You Have Test Cases That Require Periodic Execution. When The Dust
Includes Repetitive Steps, When Tests Need To Be Executed In A Standard
Run Time Environment, You Can Go Ahead And Adopt Automation Testing
Rather Than Manual Testing. Also, When You Are Very Less Time To Complete
The Test Phase, When There's A Lot Of Code That Needs To Be Repeatedly
Tested And There Are Reports That Are Required For Every Execution, Then
Actually You Can Go Ahead And Use Automation Than Manual. So The Next
Question That We Have Here Is Quite Interesting. What's Configuration
Management? So Every High Functioning Organization Has A Master Plan,
Right? The Details How They Supposed To Operate And How They're
Supposed To Achieve Their Goals And All That. Well, Software Development
And Testing Are No Different. Software Configuration Management Or SCM Is
Set Of Processes, Policies And Tools That Organize, Control, Coordinate And
Track Code Different Documentations, Problems, Change Requests, Designs,
Tools, Compilers And Libraries.