Ph.D. Thesis Page 108

(1)

Ph.D. Thesis Page 108

5.1 IMPACT OF FAULTS

The impact of any faults is to take system in non-working state. The fault can lead the either system failure or component failure. If occurred fault within system is not breaking down the working state but it may lead another fault.

Entity caused fault can be come in exists when entities related to system take an action which is not in specification of particular entity. User faults, operator faults, documentation faults are accidental faults which may arise or may not. If such faults not arise then system will work properly.

Nature wise fault can make system temporary or permanent failure.

Time cased faults cannot continue system compare to other fault. Such fault can be enabling on the basis of time factor. Once specified time goes to recover occurred fault would become more tedious.

Doggedness faults remains for long time in system, which are not easily identical by fault detection procedures. Permanents faults need to redesign or another design of the same piece of software must be done. Temporary fault cause temporary failure of temporary improper outcome which can be working property on usual state.

Boundary faults can enable system damage from the boundary of procedure, function more specifically control structures.

Resources caused fault can put certain task in fail-safe mode. As the resources become unavailable such fault can stop related task.

Dependable task are one of the most dangerous for the system. Dependable fault put system state failure

Spot caused faults may be within one component which cause failure to another component and become composite component failure.

System life phase as design faults are remain forever in system where we don’t have chance to prevent or correct such faults later on. Faults on duration are sometime permanent and sometime temporary.

5.2 FAULT LOG AND IT’S IMPORTANCE

Fault logs can be recorded systematically and this therefore helps with diagnosing and preventing problems. Fault logs can be good at identifying reoccurring faults, which

(2)

Ph.D. Thesis Page 109 could highlight problems with the computer system itself. To maintain fault logs is somehow tedious work but they are a helpful technique to keep track of many complex problems. There are several reasons to keep fault log as to keep a record of all faults. Once fault are recorded, one will be able to look at them at a later date. If faults keep occurring then it is very easy to find and propose the solution for such faults from the previous fault log.

When system software or hardware keeps breaking down, fault logs will help to fix the problem faster regarding the breaking of system. The most importance feature of fault log is that it can fix more and more faults so that solution can be derived faster and faster. One can also save the time spent on finding the faults and causes with proper solutions. In such approach system can be more productive. Fault log can help the developer and analyzer to predict the faults in advance on the base of earlier logs. It also logs the performance of technicians to finalize who is doing better than others?

5.3 RESULT OF SCRUTINY OF VARIOUS FAULT LOG IN RATIO OF FAULTS

(3)

5.4 RESULT OF COMPARISON ANALYSIS OF TESTING TOOLS

BASED ON COST

SEGUE’s Silk Performer is working for n numbers of users with various protocols and compute aware situation. Silk Performer is working in the area of forecasting of actions of e-business era. Silk Performer is enabled active without keeping reference

of complexity ( http: / / www. segue. com/. . . /index. asp ). Another testing tool

named e-TEST suite is working for manageable, host able testing load service. It is working with unlimited load generation capacity utilizing multiple points-of-presence ( http: / / www. empirix. com/. . /article&ID=419 ). For web testing tool Web Load is available. It uses as part of Test View. It includes over 70 performance metrics of transaction successes and failures. These success and failure is on separate implicit level. It is also support in fetching irregular faults with allowing test comparison metrics. Citra test is for any windows based application. It is working for application

monitoring, functional and latency testing ( http: / / www. tevron. com/citratest. asp

). The following chart represents the bottom ten prices vice testing tools. Here w filtered six lowest prices among bottom ten prices vice testing tools. A web testing tools named Site Tester is a load-testing utility. It simulates contemporaneous access of numbers of users. These users may from various hosts to web applications. ( http: / / www. pilotltd. com/eng/sitetester. aspx ). Another wev load testing tool which is also used to manage the load named SOFTLOGICA LLC‘s WAPT. It handles dynamic content, HTTPS and SSL. LOADTESTING. COM’s Portent Supreme is

web load testing tool ( http: / / www. loadtesting. com ). PowerProxy is a low cost

http/https proxy ( http: / / www. powerproxy. net/ ). STEPHEN GENUSA’s

WebHammer is use for Web applications and servers at low cost utility ( http: / /

(4)

Table 5. 1: Price vice Top 10 Testing Tools Vendor

Name

Tool Name Tool Code Approximate Price Application MERCURY INTERACTIVE

LoadRunner LR $5, 000 web and other

IBM

RATIONAL

Performance Tester

PT $5, 000 Web

COMPUWARE QALoad QL $5, 000 Web

SEGUE SilkPerformer SP $5, 000 Load, Stress &

Performance Testing

EMPIRIX e-TEST suite e-T $5, 000 Web

RADVIEW WebLoad WL $5, 000 Web

MICROSOFT Application Center Test AC $2, 999 Web REDGATE SOFTWARE ANTS Load Professional Edition AL $2, 490 . net

OPENDEMAND OpenLoad OL $2, 195 Web

TEVRON CitraTest CT $5, 000

(5)

(6)

Table 5. 2: Price vice Bottom 10 Testing Tools

Vendor Name Tool Name Tool

Code Approximate Price Application PILOT SOFTWARE LTD ( TURKEY ) SiteTester ST $29. 00 SOFTLOGICA LLC ( Russia

) WAPT WAPT $299 Web

LOADTESTING. COM Portent Supreme PS $279. 95 Web

PAESSLER ( Germany ) Webserver Stress

Tool 6 WST $624. 95 Web

HOSTEDLABS HostedToolBox HTB $20

AUTOMATEDQA http: / /

www. automatedqa. com/ Aqtime AT $599

WEBPARTNER http: / / www.

webpartner. com/ Stress Testing St T $500

PARASOFT SOAPtest and

ParasoftWebKing SPW $895

POWERPROXY http: / /

www. powerproxy. net/ PowerProxy PP $50

web servers

and show

debugging

(7)

(8)

Table 5. 3: Price vice List of above Mentioned Testing Tools

Vendor Name Tool Name Tool

Code Approximate Price Application PILOT SOFTWARE LTD ( TURKEY ) SiteTester ST $29. 00 SOFTLOGICA LLC (Russia

) WAPT WAPT $299 Web

LOADTESTING. COM Portent Supreme PS $279. 95 Web

PAESSLER ( Germany) Webserver Stress

Tool 6 WST $624. 95 Web

SIS –Florida Tech http: / /

www. sisecure. com/

holodeck/what _ is. shtml

Holodeck HD $1, 500 fault

injection

MERCURY INTERACTIVE LoadRunner LR $5, 000 web and

other

IBM RATIONAL Performance

Tester PT $5, 000 Web

COMPUWARE QALoad QL $5, 000 Web

SEGUE SilkPerformer SP $5, 000

Load,

Stress &

Performance Testing

EMPIRIX e-TEST suite e-T $5, 000 web

RADVIEW WebLoad WL $5, 000 web

MICROSOFT Application

Center Test AC $2, 999 web

REDGATE SOFTWARE

ANTS Load

Professional Edition

AL $2, 490 . net

OPENDEMAND OpenLoad OL $2, 195 web

TEVRON CitraTest CT $5, 000

(9)

AUTOMATEDQA http: / /

www. automatedqa. com/ Aqtime AT $599

WEBPARTNER http: / / www.

webpartner. com/

Stress Testing

St T $500

PARASOFT SOAPtest and

ParasoftWebKing SPW $895 POWERPROXY http: / / www. powerproxy. net/ PowerProxy PP $50 web servers and show debugging NEOTYS NeoLoad NL $2, 395

(10)

(11)

Ph.D. Thesis Page 118 The following chart represents the price vice, open source and free software testing tools ( Figure 5. 4 ). Here we discuss free tools along with their key features. Web App Stress is working for simulating various numerous browsers to check performance and stability of web application ( http: / / www. microsoft. com ). LoadTester is an extremely scalable load simulation. It tests application's behavior under conditions of heavy usage. It is used primarily for load testing and capacity planning ( http: / / www. appperfect. com/products/devsuite/lt. html ). Test Perspective is used to verify the web based application for confirming their functional effects, scalable module and further ability ( http: / / www. pushtotest. com/Downloads/ ). Load Test used on verify the application which are based on Internet as firewall application for load-generating infrastructure ( http: / / www. keynote. com ).

HEWLET’s –PACKARD is used for verify the performance of server for web

application and benchmarking tool ( http: / / www. hpl. hp. com ).

Table 5. 4: Open Source Testing Tools

Vendor Name Tool Name Tool Code

MICROSOFT Web Application Stress Tool (

WAS ) [free] WAST

APPPERFECT LoadTester LT

PUSHTOTEST Performance Kit PK

KEYNOTE Test Perspective Load Test TPL

HEWLETT-PACKARD Httperf HF

THE MEASUREMENT

FACTORY, INC ( U of CA ) Web Polygraph WP

(12)

(13)

5.5 COMPARISON BY FEATURES

The objective of this section is to try to give interesting tools available in the marketplace according to their features.

Test Tools Free

Commercial

Supported features will be represented by color: represented by color

Supported feature Legend:

Requ REgu represent the requirements supports

Speci Speci represent the management of specifications

Plan1 Plan1 management Testplans

Report1 Report1 suports for Test campaign report

Bug1 Bug1 stand for bug reporting and tracking system

ManualoIt supports Manual testing parameters

Autoo It supports automated ways and product of testing

drivers

Unito It indicated the tool used for Unit testing

Funcn It indicated the tool used for functional testing Load1 It indicated the tool used for Load testing Stress1 It indicated the tool used for Stress testing

(14)

Table 5.5: Comparison by Features of Different Testing Tools

Test Tools Test

Management Automated Test R e q S p e c P l a n R e p o r t B u g M a n u a l A u t o U n i t F u n c L o a d P e r f Free XQual XStudio QAManager QAManager Salome TMF Salome TMF

Test Case Web Test Case Web

Testitools Testitools TestLink TestLink TestMaster TestMaster Rth Rth CodeSourcery QMtest Concordion Concordion STAF STAFF JUnit JUnit CUnit CUnit CppUnit CppUnit

(15)

Ph.D. Thesis Page 121 PhpUnit PhpUnit HTMLUnit HTMLUnit XHTMLUnit XHTMLUnit HTTPUnit HTTPUnit Google WebDriver JWebUnit JWebUnit Windmill Windmill JFunc JFunc Testing Anywhere Testing Anywhere

The Grinder The Grinder

OpenWebLoad OpenWebLoad

FWPTT FWPTT

OpenSTA OpenSTA

Curl Loader Curl Loader

AutoIt AutoIt AutoHotkey AutoHotkey Marathon Marathon Java.net Jemmy Abbot Abbot GUITAR Abbot

(16)

Ph.D. Thesis Page 122 Expect Expect QAliber QAliber Tigris MBT VNCRobot VNCRobot OpenQA Selenium Frankenstein Bromine Squash Squash

Magnetic Reason FitNium

WatiN WatiN

Watir Watir

CubicTest CubicTest

Telerik WebAii Framework

JBehave JBehave StoryTestIQ StoryTestIQ TextTest TextTest Cucumber Cucumber SpecFlow SpecFlow Twist Twist Sahi Sahi

(17)

Hammerhead Hammerhead2

The Grinder Grinder

Pylot Pylot OpenSTA OpenSTA OpenLoad OpenWebLoad WebLoad WebLoad JCrawler JCrawler Hammerora Hammerora DieselTest DieselTest CLIF CLIF JMeter JMeter SIPr SIPr SIPp SIPp pjsip pjsua Commercial HP (formerly Mercury)

HP Quality Center (formerly TestDirector) HP QuickTestPro (formerly QuickTest) HP WinRunner (WinRunner) HP LoadRunner (LoadRunner) Compuware QADirector

(18)

TestPartner

QALoad

IBM (Rational) Rational TestManager

Rational Manual Tester

Rational Functional Tester

Rational Robot

Rational Performance Tester

Empirix e-Manager enterprise

e-Tester

e-Load

TestPad TestPad

Microsoft TFS Test Manager (VSTT)

UTest UTest

Parasoft JTest

C++Test

WebKing

T-Plan T-Plan Professional

Verisium vManage

vTest

(19)

Ph.D. Thesis Page 125 Seapine TestTrack TCM TestTrack Studio QA Wizard Pro APTest APTestManager PassMark Software TestLog

Gurock Software TestRail

Conformiq Qtronic SG

Qtronic GP

MKS MKS Integrity

Original Software Qualify

TestBench

TestDrive

TestDrive Assist

TestMasters TMS

Zephyr Zephyr

Ken TestMan Ken TestMan

CodeSourcery QMtest

Inflectra SpiraTest

Prima Software Solutions

JITE (plugin for JIRA)

(20)

Ph.D. Thesis Page 126 JadeLiquid Software LiquidTest SmarteSoft SmartQM SmartScript SmartLoad TestOptimal TestOptimal LordUI LordUI Objentis QAS.TCS

mjtnet Macro Scheduler

TechExcel DevTest InformUP TestUP ID Consultants DuxQA @YourSide Consulting ATD Testuff Testuff

CatchLimited Enterprise Tester

TOMOS TOMOS PractiTest PractiTest QMetry QMetry ITCampus Web2Test DigitalTester DigitalTester Polarion Polarion

(21)

Ph.D. Thesis Page 127 GenieSys GenieTCMS TestRun TestRun TestWave TestWave OpenGroup TET FrogLogic Squish Ranorex Ranorex Dartenium Dartenium

Badboy Badboy + Wave Test Manager

iOpus iMacros

soapUI soapUI

InCisif.net InCisif.net

Minq Software PureTest

PureLoad PureAgent Quotium QTest AutomatedQA TestComplete Elvior MessageMagic XML-simulator SoftwareResearch TestWorks DurableSoftware TestManager

(22)

Webius Software SWExplorerAutomation

Wintask Wintask

Origsoft Testdrive Gold

Testdrive Assist software for Plan9 Qualify ITKO LISA Microsoft VisualStudio 2008 Orcanos QPack SoftLogica WAPT Exept Software AG Expecco ExpeccoNET

Telerik WebUI Test Studio

SmartBear QAComplete

DevComplete

Zeta Test Zeta Test

(23)

Table 5. 6: Comparison of Web Testing Tools

Web application Testing Tools Web browser based application Scripta ble Scripting Language supported Record er Multipl e domain Frame s HTTP S Ranorex Studio Supported Suppor ted C#, VB. NET Support ed Suppor ted Suppo rted Suppo rted ( Chrome, Firefox, Safari, IE )

Selenium Supported Suppor

ted Ruby, Java, PHP, Perl, Python, C#, Groovy only Firefox Suppor ted

SOAtest Supported Suppor

ted Python, JavaScript , Java Support ed Suppor ted Suppo rted Suppo rted TestComple te Supported Suppor ted VBScript, JScript, C++Script , C#Script, DelphiScr ipt Support ed Suppor ted Suppo rted Suppo rted ( IE, Firefox, Chrome ) TOSCA Testsuite Supported Suppor ted Java, C#, VB6 Support ed Suppor ted Suppo rted Suppo rted ( IE, Firefox ) WatiN Supported Suppor ted C#, ability to run JavaScript from C# calls IE/FF Suppo rted Suppo rted ( IE ) Watir Supported Suppor ted Ruby Support ed Suppor ted Suppo rted Suppo rted ( IE, Firefox )

(24)

5.6 LIMITATION OF TESTING AND TESTING TOOLS

Testing has some limitations that should be taken into notice to set sensible prospect about its benefits ( Zambelich, 2007 ).

 It identifies the known issues or errors but it will not give idea about defects

which are remaining uncovered. Testing and testing tools will not give guarantee about the error free system. Testing will not help to make a decision about release the system with errors for deadline notification.

 Testing can’t begin as system functioning properly in all conditions. The focus

of testing and testing tools is to guarantee that system will not function properly under specific conditions ( http: / / www. sisecure. com/. . . /what _ is. shtml ).

 It cannot help to find dependable errors in various components.

 Software testing is not focused and targeted in finding root causes. Such causes

may be resulted in insertion of faults.

 It can’t test a program completely.

 Every path of system is not tested by testing tools or test.

 Testing tools or test cannot test every valid input

 Every input is not tested thoroughly.

 It can only test against system requirements

 May not detect errors in the requirements.

 When incomplete requirements is pass on to system then inadequate or incorrect

testing will done.

(25)

5.7 IMPLEMENTATION SOFTWARE FAULT TOLERANCE

TECHNIQUES

The existing techniques will start with a demo application of a Sorting. This application will focus to build the sorting features for three Sorting servers. The server where sorting application is going to implement is combining various programming levels. A variation of the sorting is received an object along with list of integer, sorting the list, input data, procedures and many thing more. Same application is sending the result back to the application. Here is one interface called ItemList which include the Sorting mechanism in the form of function, when we create the object of the same class and call the method that can help us use differently like quick, RCB, NVP etc. One of the Method ( function ) of class ItemList will use different kind parameters. It will use various inputs later in the sub-classes of ItemList. The interface will become the reusable components of the system which will use whenever the same set of code is required.

Public interface ItemList

Function Itemlist( ByVal k As Integer ) As

IntegerFunctionvector( ByVal k As Integer ) As Integer End interface

To implementing SFT techniques with the use of mentioned example, the platform to execute functionality visual basic library programs is implemented. Such programs are provided by the system programmers to implement the sorting control methods for different fault tolerance techniques. Here, various classes, interface, method as function and procedure is given for the control sorting mechanism for different server. The RcB and, N-version programming is going to implement in current section along with socket interfaces.

Public Interface FaultT1

Function Variation( ByVal port As Integer, ByVal machine As Char ) Function QuickSort( ) As Integer

(26)

Ph.D. Thesis Page 132 Function NVP( ByValObj As FaultTolerance1 ) As Boolean

End Interface

In this study, interface for the different faults tolerance techniques that can be bound within one code. Interface FaultT1 having three techniques of Design diversity would use for relative fault managing. At this point FaultT1 is the interface of the reference type that will be used by the various classes in the remote servers. The control structures given in example return a Boolean result. The results generated which can able accept is TRUE and the result generated which cannot able accepted as incorrect is FALSE. The implementation of technique named Rcb for any part of executable mechanism is going to take place in system origin as below by the system programmer.

Public class Item

Implements FaultT1, ItemList

Dim s AsSystem. Net. Sockets. Socket

„Implements all property and method from interface „Action (event)

Public function RCB( ByValObj As item ) implements FaultT1. RCB „Use socket class

Dim BK As item BK = Obj

fori=0 to i<variations „Try alternate/Variation

s. Connect( "host as string", Port as integer ) s. Close( )

if ( obj. Arbitrator( ) ) then „ Assurance of successful test

‘Recovering the expected the object allocated from the dynamic memory and try „Another alternate/Variation

Else

(27)

Ph.D. Thesis Page 133 end if

„ All option which is given as alternative in form of code is failed then Returning ( Boolean-false )

Next iteration as i End function

„define each method from interface

Public function QuickSort( ) as integer implements FaultT1. QuickSort( ) Dim ob2 as Items

Dim err AS Boolean

Private Sub BubbleQuickSort( ) Dim temp As Integer = 0

For j As Integer = 0 Toarr. Length - 1

For k As Integer =( arr. Length )-1 To j + 1 Step -1

IfCInt( ( arr. GetValue( k ) ) )<CInt( ( arr. GetValue( k - 1 ) ) ) Then temp = CInt( arr. GetValue( k ) )

arr. SetValue( arr. GetValue( k-1 ), k ) arr. SetValue( temp, k - 1 )

End If Next Next End Sub

Obj2. variation( p1, "node1. a" ) Obj2. variation( p2, "node2. b" ) Obj2. variation( p3, "node3. c" ) err = Obj2. RCBlock( list ) return err

End class

At this point, Item is class which implements the FaultT1, ItemList. As it implements, means it uses the concepts of multiple inheritance, it can use all the property and methods of implemented interfaces. When the result comes back, referee operations are performed. If the result is acceptable, it returns TRUE, or, otherwise object is restored and the following alternative holds. If all the deputies are

(28)

Ph.D. Thesis Page 134 not satisfied, the operation RcB returns an error as false value form the registered Boolean value. These experimental programs can be easily modified using various communication protocols. RPC is one this communication protocol which is used by the system. here, to implement SFT component, the reusable control structures provided which can easily construct various versions in the form of sub-classes as ItemList class. The SFT designer has proposed variations to indicate the objects which will be handled by the FaultT1 interface.

Public function NVP( ByValObj As item ) implements FaultT1. NVP Dim i as integer = left

Dim j As Integer = right Dim temp As Integer

Dim pivot _ _ 1 As Integer = CInt( arr. GetValue( Pivot( right, left ) ) ) While i<= j

While CInt( arr. GetValue( i ) )< pivot1 i += 1

End While

While CInt( arr. GetValue( j ) ) > pivot1 j -= 1

End While If i<= j Then

temp = CInt( arr. GetValue( i ) ) arr. SetValue( arr. GetValue( j ), i ) arr. SetValue( temp, j )

i = i+1 j = j- 1 End If End While

If left < j Then ( pass parameter as left to procedure ) QuickSort( left, j )

End If

(29)

Ph.D. Thesis Page 135 QuickSort( i, right )

End If End Function

The QuickSort( ) is defined for the different objects from different nodes which can use it. We can achieve few advantages of this approach as no change to the compiler. It can enable to free practical hands on as experiments and little decreasing of unnecessary burden via various code performs on the SFT practitioner. To utilize the library routines by the application programmer, programmer must be fully responsible for correct use of library resources. The use of library programs must be strictly adhered by the programming conventions for relating it to all checks. As all parameter will check, the result would be in faithfulness which can be performed and justified by the efforts of only by SFT practitioner. It is not limited upto this phase but in addition, traditional program make a strong bridge over the code and additional code used in the application. The same approach is an evident partition between original s/w building code and alternate code for SFT system. In the wave of same approach and to support sorting with SFT QuickSort proposed for achieving Design diversity.

Public class FMT Inherits Item

if ( NOT obj. List ) then „Use NVP( . . ) Else „useQuickSort( ) End if End Function End class

Suppose quick sorting is required to implement by someone for SFT. Here is QuickSort( ) operation for SFT. Here used quick sort fundaments in the association with operation fundamentals with QuickSort( ) reflective manner. Very first it inherits few used class of vb. net. the important and remarkable things is that the

(30)

Ph.D. Thesis Page 136 control mechanisms in FMC which is implemented with use of Item class and FaultT1 class both. Item is derived from Itemlist which treated as sub objects. Further, we can create any class that can use our earlier defined class for achieving same functionality.

5.8 EXPERIMENTAL EVALUATION

In our experiment we use . net environment to execute the code. Here , three sever need to communicate with clients and servers which is performed by the use of TCP / IP and implemented with System. Net. Sockets. The communication used by current mechanism is effective to support this experiment. A special object that provides functionality for connection which is over network with System. Net. Sockets. Socket. Two operations performed by the use of Socket programming. It compasses of many methods and one of these is the Connect ( ) methods which is establishing the connection among the server and clients. The connect ( ) method will send the object on the server, and Close ( ) is working for obtaining the result from the server by closing the established connection.

Table 5. 7 Performance-Related Testing OUTPUT

Test 1 2 3

QuickSort O/P DONE NOT DONE NOT DONE

Time 2089 289 2207

RcB O/P DONE DONE NOT DONE

Time 4312 14004 4225

NVP O/P DONE NOT DONE DONE

(31)

Ph.D. Thesis Page 137 In order to examine the effectiveness of SFT techniques which is implemented, software-fault inoculation is performed by testing methods. Here we have three techniques of fault tolerance which wrapped in reflective code through interface, class and function as QuickSort, RcB and NVP. The O/P of the each method’s execution time was measured. This time which is represented in diagram is counted in micro seconds whose symbolic representation as μ seconds. The time of network communication among the various user as server and clients is considered as constant in given application. To measure the times, data set of 200 elements was used to apply SFT efforts. Here is chart representation of the data of above table 5. 7. In Test One named T1, QuickSort operation was executed without any fault inoculation methods. The functioning of this test resulting in correctly sorted. In compare to other dependable versions based on RcB and NVP. It says that variant code for sorting over the different communication node has longer execution time. Such variant versions are the faster versions of the normal Sorting operation over the client and server communication. RcB which uses QuickSort as its first alternate is executing in achieving the proper sorting data. As RcB is slightly overhead and increase the time of execution along with result carried out. The reason behind it is acceptable tests usage. The design faults were also inserted into the server while the process under the class QuickSort operation. During such operation failure occurred at QuickSort. The RcB can still working to generate proper sorting. NVP fails are showing that when multiple correct outcomes in reference of sorting are possible done. The voter some time failed to choose the most appropriate of three different results. Here, the time of NVP is shorter than that of RcB.

(32)

Figure 5. 6: Performance-related testing OUTPUT

In the last test, few acceptances test where few software faults cannot be detected by provided cases. Such test cases data were injected into the function Sort server. The same will apply to both QuickSort and RcB produce . Whatever injected into function among all those few of them come across erroneous lists without marking any error. The outcomes are as per the very first test. NVP can tolerate any types of such faults in most effective manner.

5.9 SELECTING FAULT TOLERANCE TECHNIQUES FOR

PROTECTION OF VARIOUS FAULTS

The direct concern for SFT designs is to make more reliable and to increase the working capability of system though there is an existence of faults. Fault can be define by various ways. One of them, Fault is an anomalous condition, accidental creation, unpredictable interrupt occurring in the system hardware or software. The selection of the fault tolerance techniques from reliability enhancement and cost effectiveness for the critical system is depends upon the requirements of the system which will need the assisting of software system. Fault tolerance can be applied to various set of various types of applications as life critical, military, aerospace,

(33)

Ph.D. Thesis Page 139 moving industry, commercial applications and specially high-availability. Application associated with Life Critical, atmosphere critical, data critical, resource critical require a elevated scale of assurance. Such applications need supper high assurance for safe functioning and accuracy of the computer system. Such System which prevents many dangerous things from damage. When maintenance is extremely long to operate as intended with a high probability, long-life applications are required. Delayed maintenance applications have extremely costly, inconvenient, or difficult to perform maintenance. Because of such nature of application, system designing must be reach to reliability in appropriate manner with prospecting of predicting the faults. SFT can make any application to perform to achieve the desired requirements satisfy under a complex situation. Development programs must be according to development risks associated with technologies from failure to availability within a reasonable time frame.

Here, different faults were analyzed in the reference of mentioned embedded system which can be managed by the fault tolerance techniques. We start with specification faults, ( 1 ) which can be managed by the rechecking design specification. Design faults ( 2 ) can be managed by Design diversy ( NVP or RcB ). NVP use multiple versions of the same requirements, where we can divert to another version on chosen design. In NVP if one of the designs fails, at least one alternate version will work. Implementation faults ( 3 ) which need to check properly before getting in use. We can use Verification, error detection and check point techniques. User faults ( 4 ) are of different types but generally it will wrong range of data which can be solved by input limit checking, exception handling. If user gives improper input so it would be handled by exception or checking the limit. Operator faults ( 5 ) which may work n improper instructions which can be managed by n-self checking or data diversy. If any hardware or part of hardware would fail because of any reason we can apply hardware fault tolerance. Hardware fault tolerance gives alternate component for failed component.

(34)

5.10 RESULT & DISCUSSION OF PROPOSED DCE DIVERSY MODEL

Every day an advanced technology and tools are introduced in IT industry to enhance the power and performance of software as well as cost and time effective developing approach. Fault can increase the cost of system ( Westland, 2002 ). Ultimate goal of any project, system or software is to satisfy user requirement. As per the convention phases of SDLC the analysis of the system would take place in the initial phase. From analysis one can able to write requirements specification for the same system. The faults which may arise during this transient will pass on to design phase. The fault cycle can’t stop here. Undetected fault from Design phase may lead to the inappropriate developing/coding. The outcome of such system chain process where fault are executing at each stage would be in unacceptable objective and mismatch with user requirements.

This section, emphasize on fault outline of various system life phases. While the life phase chain is running for a particular or in general, system may have fault at any phase. Ideally whatever the faults are there in particular phase; it must be managed within the current phase. If faults are managed phase wise then design fault will not detected at the testing phase. The design fault can managed during the designing of the system, and same for other phases of system development. This study introduces the Design, Code and Environment diversy Model ( DCE Diversy model ). Proposed DCE Diversy Model is enhanced from the basic system life phases. If any faults related to requirement of system exist then design diversy will active to manage the faults. As stated in the Fig: 5. 1 the faults associated from requirement writing to design specification are interpreted by the design fault and redirect the flow to design diversy. The detail of functioning of specification phases and sub phases is mentioned in the next section.

(35)

Figure 5. 7: Design, Code and Environment Diversy Model

Once mapping from requirements to design was completed, the next task of system to develop the design with aid of software tools and techniques. Now, developer has put initial two phases into real world application by applying the code as per necessity. Fault may arise any time anywhere. The maximum faults in form of bugs or errors can take place at time of development ( Hille et al, 2008 ). Respectively those many faults also be notified and corrected during the same phase. Whenever faults associated with code arise, code diversy exploration is necessary. It will direct the developing faults from development environment to code specific modules. Logical and physical system configuration must match with the targeted system. Implementation task will not only look up for software configuration but also hardware configuration. Whenever implementation faults arise, the propose DCE diversy model can manage the situation by providing alternative resources in form of redirecting the implementation faults to Environment diversy. After diverting flow at

(36)

Ph.D. Thesis Page 142 different stage, the forecasting of faults in reference to specific system can be possible.

5.11 RESULT AND DISCUSSION OF PROPOSED DESIGN

SPECIFICATION FAULT SCRUTINIZE MODEL

The first stage of software system is analysis, second one is designing, third is developing and implementation ( Senn, 1999 ). After system analysis, system designing is very important and attentive which met the objectives with integrating the function, interface and the components.

In present model, our objective is to give specific description in right form for specific phase of functional behavior and description with fault analyzer. Description of structural rudiments as data, module, interfaces and components are connected by the fault analyzer. The specifications are also very important. The importance of specification will target the factor of improvements which involve competence, usability and ability to maintain the software system ( Georgiadou, 2003 ).

This study presents the comprehensive model for the system specification fault monitoring. This model exploits the analyst effort to achieve fault free design configuration. Developer has to keep key eye on each requirements of system as complete specification of their logical structure, behaviors functions, and data for providing the acceptable system design. For system, concise information of tools technology and hardware requirement is prominent. The possible mismatches, such as absence of essential modularity, should be easily detectable. The mismatches reside at the various log should be corrected by using suitable fault log. The specification logs are effectively identified by listener and manager, which will help to established standards design.

(37)

Figure 5. 8 Design specification fault scrutinize model

Generally a mismatch in the transit component can lead higher numbers of mismatched in the further stage of requirement usage. The specification listed must be based on suitable form of data expected from various entities related with the modules, interfaces or components. The same requirements can be use for redevelopment of the system. An emblematic requirements specification may state that the collected, written or specified things will be portable and flexible to maximize and make system scalable for all feasible environments with design creation flexibility.

Design specification ( DS ) Fault scrutinize Model ( Fig: 5. 2 ) come in obtainable with the details of analyzed system. The model’s task begins with system listener which has facet information in-depth of all tasks. Such information should be ground covered for achieving the objective of required system. All these details will reside within system requirement log.

System specification can be of various types ( Roman, 1985 ). The study focuses on specifications from the received requirement log to maintain interfaces. Specification Listener will perform the matching of requirement information log to requirements specification. With the use of requirement log and specification log system diagnosis will maintain the specification diagnosis log to scrutinize all log details.

(38)

Ph.D. Thesis Page 144 Fault cannot be tolerated in any system in any circumstances ( Chillarege, 1996 ). The main objective of proposed model is to cover the fault occurred in transit of requirement gathering and design specification stages. As we mentioned earlier, fault can be of many types but in this section, the research going on the specification faults which may lead improper and squat control design concepts.

System specification fault listener will use requirement log, requirements matching log and system diagnosis log to find faults take place during conversion of specification into system design. Fault diagnosis will guide the system in more details. Fault manager scrutinize the various log with the help of fault listener and log. Matching of the different types of specification by applying scrutinize on fault log and specification log, one can easily draft out the depth structure specification for different types of data and their flow. Functionalities of system can be easily structured by appropriate data and flow. Once developer establishes doubt free functionality, module can be more active to build up various components. Fault free working flow from the data specification to Interface binding will converted in accurate specification tasks along with high performance system components. This model can help to solve the issues of software/system design which is mentioned in previous section. Understanding the inputs and process and tie up with boundary expectation is very clear as they are passing through various sub phases and various listeners match them with objectives of system. Once, specified fault free data form in functionality specification, such behaviors of functionality can lead more appropriate module, component and interfaces. The gap between software layers to implementing environments is come in picture when details specification is performing for the same system with obtaining desired objectives. Summarization of all tasks by the proposed model can provide most suitable and standard design with fault forecasting.

(39)

5.12 RESULT AND DISCUSSION OF PROPOSED SOFTWARE FAULT TOLERANCE MODEL

As discussed earlier in 4th chapter, failure free operation in past as well as in current,

it not indication of no future failures. Fault tolerance detecting faults and managing the detected faults to remain state as per the demand. Software fault tolerance work on the fault life cycle as fault detection, fault isolation, fault diagnosis, prevention of proposed faults, predicted fault removable, fault tolerating and finally fault forecasting. Each parse of fault cycle react on fault in its own nature.

The proposed model is introduced for targeting high reliability along with fault forecasting. This Model can function according fault life cycle with the use of basic measure as MTBF in development of system. There are conceptually and many basic differences reside between an ordinary software system and a fault tolerant system. Such differences can belong from developing, designing, testing or implementing. The fault tolerant system spends higher numbers of all efforts in each phase of system development. Whatever system is going to be build under the criteria of good designing or good programming efforts’ but reliability is not guaranteed at all. The proposed model for SFT can increase the reliability of system up to some extent. Before introducing the working of Model, the life phase of SFT system must be clear. SFT life phase arranged as Feasibility study of SFT System, requirement gathering, specification writing, specification fault matching, designing, design fault matching, coding, developing fault managing, testing, test log matching, implementing and objective matching.

(40)

Figure 5. 9: SFT Life Phases

If objective matching done properly, then fault forecasting cannot be active. In reserve the fault forecasting can help system to forecast various type of fault which may take place in any of the SFT life phase. In SFT life phases ( Figure 5. 9 ) some of phases are as similar to conventional SLP, so here the rest of phase working for SFT system is key in central. SFT life phases involve the working from basic requirement gather to implementing the SFT system. The new phases involved here are fault management phases. After completion or ongoing phase of System as requirement writing to specification justifying, it attached by specification fault securitize log. Designing phase is collaborated with designing fault management by design diversy. Further development phase is connected with code faults which range in very large suit. Once developing is near to furnish testing require extra effort to test whole SFT system as it is combination of numbers component and sub system parts. Finally, the objective testing of desire outcomes is done along with all fault

(41)

Ph.D. Thesis Page 147 manager belong from various phases to forecast about the fault which may happen during the system.

The fault managers are not enough for getting high reliable system. Here, one of the important measures as Mean time between failures is plugged with fault life cycle and fault managers in system life phase. The proposed model various fault managers at various SFT life pauses. Each of these fault managers is scrutinize with Fault log. MTBF can be derived from mean time to failure and time taken for recover the identified the faults. The fault logs will register all faults detected and identified according to their phase of creation which are categorized in particular type of faults. The fault managers use various listeners as programs or set of programs to scrutinize the logs ( Figure 5. 10 ).

(42)

Ph.D. Thesis Page 148 After scrutinize the logs, listeners can produce the resulting subset of faults. Such faults can be used to take action in respectively phase. Once faults are registered in various logs, further any faults occurred it will match with existing faults. If matching found by fault matcher, the fault origin can be diverted to respective diversy. During the matching process of faults to the faults log, design faults can be diverted to another design. The developing faults can be diverted to another peise of code or subsystem. In the similar way testing and implementation faults can use another approach to deal with occurs faults.

The various fault logs contain various numbers of faults which may occurred during from basic phase to objective meeting phase of system. Any faults registered at that time along with fault details, the fault log keep details of location of faults with timing of same faults. In the proposed model, MTTF can be found from the various fault log which already stored the timing constraints for xyz fault. After getting mean time to failure, the models focus on diverting the flaws to manage the faults. The diversion of any faults will pass to another alternative by the same working states meanwhile the occurred fault solution can be provided through the diverted alternative. If prevention or tolerating of fault was successfully done then the timing constraints for the solved out faults are detailed store at faults log as mean time to recover from faults.

Now, faults log has the information about the fault occurred details and fault recover details. So that one can easily find out the mean time between failure which is the gap between the fault occurred and recovery process. After mapping MTBF from various systems, one can state the reliability of system with the use of mean time between failures and also get assurance of how much tolerant system is there.

(43)

5.13 DISCUSSION OF SFT FOR RELIABILITY ENHANCEMENT

As discussed in earlier section reliability plays an important role at system implantation. In current section reliability enhancement is proposed by applying SFT techniques and model in various application as thin client and robotic sugary systems. The observation says that failure is taking place in many of programs or states in the process of transient. The environment approaches and diversity approaches is fundamentally based on re-implementation or re-executing of same piece of code or part of code in a various environment. Such approach will offer diversity concept for the environment diversify effectively. Here, the same concept is explored with Heisenberg‘s fundaments ( Yarden, 2005 ). The approach for environment diversity is nothing but provide a restarting of functionality in various ways. This technique is famous as one of the effective techniques in development in series of SFT system. There are many factors to determine the SFT application’s behavior of the particular process out coming or execution carried out.

5.13.1 Thin Client

The thin client system is a system or a program which work behalf of other computer as its server to fulfill its traditional computational roles ( Vlissidis and Hickey, 2010 ). In thin client environment, all system may not have all devices but use all devices centrally. Here we introduce the thin client with fault tolerance environment. Thin client performance is proposed to improve by enabled it with latest SFT techniques, models and hardware fault tolerance ( Francalanza and Hennessy, 2007 ). It provides functioning of thin client environment under faulty environment with high reliability. Given approach work on satisfied requirement.

(44)

Figure 5. 11: Thin Client Environments with H/W and Design Diversy

The protection in environment diversity approach is focus on many basic care taking fundaments from computer technology. As Examples includes the basic operation of restarting and rebooting the expected node. The problem which is not handling by the particular node that problem will use alternative resource for generated instruments or hardware failures ( Stoianovici et al. 1998 ). If any resource from another component is missing or inactive for the particular component which is in executing mode, the most suitable approach is to use alternative resource. As a thin client works with minimal resources, so we can accommodate alternate h / w system. It would be easier for the thin client system to fit it with H/W Fault tolerance.

The approach for managing, handling and securing the errors for any specific part of software, mistake occurred at particular part of software or diversion of execution is discussed in the reference of above example. In the thin client, server is the most loaded nodes. There are certain situation in thin client where any node or client is facing the problems of software which expect an answer and the node or client is not able to answer due to certain factors. The divert execution of the software from one to another will not make such situation and it will keep your client node to continue

(45)

Ph.D. Thesis Page 151 for providing services. In associated approach, the solution as part of software alternative as code multiplication with same objective is very useful. The dealing of inputs and with multiple copy of piece of information will cause assure for output. The SFT technique RcB is work on the bases of using various acceptance tests. When execution started first it check the primary execution , if it is according to the requirements or meet the satisfactory level then ok otherwise go to another alternative. The RcB gives us many alternatives up to few extend. When we have many nodes that all are managing by many system, it’s difficult to provide RcB for them in various ways. But in Thin client every system handle by Sever, so we can give strong reliability in reference to cope up with faults. The scenario will change on condition to assign another part of code section to the system.

With the existence of various software pieces in NVP, the execution has some traditional ways. It starts with initial version of the system or first pieces of code to be executed first which is associated with the server. Whenever fault will take place, the execution will move to the alternate portion of code, module, system component or next version to solve the problem. The application which is loaded to the client from the server, such application paced in different version. If first version of said application is not responding on requirements then it passes to another version and execution may completed accurately. The faults are managed and execution done as it required is confirmed from unavailable of occurred faults. As we already said in thin clients, most of the work loaded server node. Again it’s difficult to provide many copies of many system form many nodes but Thin Client can easily adopt the NVP to deal with faults. The N-version will work to give satisfied answer and results to the clients in thin client environment.

5. 13. 2 Surgical Robots

To supports advance technology in surgical mechanism, many surgical robotic devices are popular in current trends. These devices are having variety range of functions in their own nature of performing variety of tasks. As an example of such device as a surgeon’s right choice as third hand for accessing during the operation to move the camera is robotic device ( Kumar et al. , 1999 ). Some others devices are there to support telesurgery, tele-monitoring and many more. The revelation

(46)

Ph.D. Thesis Page 152 systems onto a multi-purpose workbench-like platform ( Lanfranco et al. , 2004 and Taylor et al. , 1999 )

The surgical robotic system is assisted by fault tolerance environment. Surgical robotic system’s performance is proposed to improve by latest SFT techniques, models and hardware fault tolerance. To functioning surgical robotic system more accurately under faulty environment with high reliability SFT models and techniques will help a lot.

Figure 5. 12: Robotic surgery with H/W and Design diversy

In the absent of services which is provided from the outer or inside and not reacting properly, the option of carry out work in another way by alternative equipment. The approach which present the flow of execution to manage bugs, errors, suspicious code in better way buy handling the problems in one of the piece code. The working activation during the robotic surgery is highly important phase to deal with situation. When such situation faces any software or hardware problems which could not able resolve, it is the most dangerous phase as it deepens on life critical application. In such role, system must continue to provide service, system must respond in the area of faulty environment from preventing big loss of system. Such loss of system, system data, resource, and series of services can be affected by software errors,

(47)

Ph.D. Thesis Page 153 faults and problems. The most suitable way of dealing with such problems are diverting the flow of execution from one to another model. The divert execution of the executable software will not cause system failure when any robotic surgery system facing s/w problem to answer the client node in any way. Instead of single code execution, here some piece of information enabled in code cover can deal with desired inputs and make confirm that the results is as per required output.

The doctors and surgeons can have take advantages of Robotic surgery. It is an important helping hand to them for performing their tasks and administering surgical operations in better way. The quality of surgical system which is implemented with fault tolerant protocol can extensively improve the performance and accuracy of surgeons’ support. The important factor in reference of using SFT robotic system or SFT surgical system is proper evaluation planning and deployment planning. Software and hardware fault tolerance technique are focused to improve the conventional techniques. It not only improves the conventional techniques but also focuses on a new approach to solve the issues of Robotic surgery system to enhance the reliability. The concluding phrase can be presents as the system associated with all application in reference to the SFT techniques is relatively new, effective, work worthy, powerful, time saver, accurate result supported to the era of Robotic surgery. The SFT Techniques as RcB and N-version which is working very powerful and appropriate at many of the solution providing situation. The System and application for Robotic surgery, the proposed concept is one of most adaptable elucidation for managing various types of faults. Robotic surgery system having the effect from proposed approach create and can increase strong steadfastness and performance.

(48)

5.14 RESULT & DISCUSSION OF SIMULATED BI-VER TECHNIQUE FOR SFT

The new simulated BIVER technique is introduces to handle the faults occurred at execution time. This is based on the combination of single and multi version techniques. It excludes the single version problems which knot for the restricted piece of code. It elaborates the benefit of multi version technique by focusing various piece of code to protect various type of fault along with keep in flexible redundancy of code.

A classical n-version technique which is twisted n-version program or n-version of code for the same part of system to protect it from failure. This technique is not appropriate when large system is tolerated.

The multiple copy of same code will increase the cost and programming efforts. We enlighten atomicity of program actions and decision verification with the use of fix version of program redundancy. The proposed technique will manage different levels of software by providing various versions with the introduction of an individual code. This code can fix one version of the n-version system.

The said technique is implemented by;

1. Fault. Tolerance. Smart Handling : This project is windows app which works for demo.

2. Fault. Tolerance. Sorting. Lib : This project is business library and contains the actual code which take cares of faults and continues to give result without failing. Three main classes Fault Handler. cs, Fault Tolerance Exception. cs and Sorting Helper. cs are coded to execute the simulated technique.

3. Fault. Tolerance. Advance Versioning. Test: This project contains the actual test cases which run these test cases too for demo. One of most used VSTT ( Visual Studio Tools for Testing ) from Microsoft as it is integrated with Visual Studio and it provides easy way to create the unit test cases, functional test cases. VSTT has all the testing capabilities such as DB testing, web testing; load testing, UI testing, automation and build testing.

(49)

Ph.D. Thesis Page 155 {

public frm Fault Tolerance( ) {

Initialize Component( ); }

private void Form1 _ Load( object sender, Event Args e ) {

}

private void btnSort _ Click( object sender, Event Args e ) {

RefreshScreen( );

int totalInputs = Count Inputs( );

Object[] data To BeSorted = new object[total Inputs]; Assign Inputs( data To Be Sorted );

(50)

Ph.D. Thesis Page 156 dataType = Assign Data Type( dataType );

SortingHelper sorting Helper = new Sorting Helper( ); try

{

object[] sortedData = sortingHelper _ SortData( dataToBeSorted, dataType, chk Enable Fault Handling _ Checked ); SetOutputValue( sortedData );

}

catch ( Exception ex ) {

Lbl Error Display _ Visible = true;

Lbl Error Display _ Text = "Invalid Cast exception is thrown"; }

}

private string AssignDataType( string dataType ) {

if ( rbtDouble _ Checked ) dataType = "double"; else if ( rbtInt _ Checked ) dataType = "int";

else if ( rbtString _ Checked ) dataType = "string"; return dataType; }

private void AssignInputs( Object[] dataToBeSorted ) {

if ( txtInput1 _ Text _ Trim( ) != "" ) {

dataToBeSorted[0] = txtInput1 _ Text; }

(51)

Ph.D. Thesis Page 157 {

Data To Be Sorted[1] = txtInput2 _ Text; }

}

private int CountInputs( ) {

int totalInputs = 0;

totalInputs++; }

(52)

Ph.D. Thesis Page 158 if ( txtInput3 _ Text _ Trim( ) != "" )

{

totalInputs++; }

return totalInputs;

}

private void SetOutputValue( object[] sortedData ) {

if ( sortedData != null ) {

if ( sortedData[0] != null )

txtOutput1 _ Text = sortedData[0] _ ToString( );

(53)

Ph.D. Thesis Page 159 if ( sortedData[3] != null )

txtOutput5 _ Text = sortedData[4] _ ToString( ); }

}

private void RefreshScreen( ) {

lblErrorDisplay _ Visible = false; txtOutput1 _ Text = ""; txtOutput2 _ Text = ""; txtOutput3 _ Text = ""; txtOutput4 _ Text = ""; txtOutput5 _ Text = ""; }

private void ClearData _ Click( send obj, e as argunments of Event ) {

txtInput _ parameter1 _ Text=""; txtInput _ parameter12 _ Text=""; txtInput _ parameter13 _ Text=""; txtInput _ parameter14 _ Text=""; txtInput _ parameter15 _ Text=""; RefreshScreen( );

} } }

(54)

(55)

Ph.D. Thesis Page 161 }

} }

<?xml version="1 _ 0" encoding="utf-8"?>

<Configuration Condition=" '$( Configuration )' == '' ">Debug</Configuration> <Platform Condition=" '$( Platform )' == '' ">AnyCPU</Platform>

<ProductVersion> </ProductVersion> <SchemaVersion>2 _ 0</SchemaVersion> <ProjectGuid>{BAC0704E-9F18-4680-A857-9049504B9EA7}</ProjectGuid> <OutputType>Library</OutputType> <AppDesignerFolder>Properties</AppDesignerFolder>