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 Ph.D. Thesis Page 108
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 Figure 5. 1 Scrutiny of Various Fault Log in Ratio of Faults Ph.D. Thesis Page 109
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: / / www. genusa. com/iis/webhamr2. html ). Ph.D. Thesis Page 110
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 REDGATE SOFTWARE Application Center Test ANTS Load Professional Edition AC $2, 999 Web AL $2, 490. net OPENDEMAND OpenLoad OL $2, 195 Web TEVRON CitraTest CT $5, 000 NEOTYS NeoLoad NL $2, 395 Ph.D. Thesis Page 111
Figure 5. 2: Price vice Top 10 Testing tools Ph.D. Thesis Page 112
Table 5. 2: Price vice Bottom 10 Testing Tools Vendor Name Tool Name Tool Code Approximate Price Application PILOT SOFTWARE LTD ( TURKEY ) SOFTLOGICA LLC ( Russia ) SiteTester ST $29. 00 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/ WEBPARTNER http: / / www. webpartner. com/ Aqtime AT $599 Stress Testing St T $500 PARASOFT SOAPtest and ParasoftWebKing SPW $895 POWERPROXY http: / / www. powerproxy. net/ PowerProxy PP $50 web servers and show debugging STEPHEN GENUSA WebHammer 2. 0 WH $49 Web Ph.D. Thesis Page 113
Figure 5. 3: Price vice Bottom 10 Testing Tools Ph.D. Thesis Page 114
Table 5. 3: Price vice List of above Mentioned Testing Tools Vendor Name Tool Name Tool Code Approximate Price Application PILOT SOFTWARE LTD ( TURKEY ) SOFTLOGICA LLC (Russia ) SiteTester ST $29. 00 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 other and 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 REDGATE SOFTWARE Application Center Test ANTS Load Professional Edition AC $2, 999 web AL $2, 490. net OPENDEMAND OpenLoad OL $2, 195 web TEVRON CitraTest CT $5, 000 HOSTEDLABS HostedToolBox HTB $20 Ph.D. Thesis Page 115
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 STEPHEN GENUSA WebHammer 2. 0 WH $49 web Ph.D. Thesis Page 116
Figure 5. 4: Price vice Testing Tools Ph.D. Thesis Page 117
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 ACME LABS SOFTWARE Http _ Load HT Ph.D. Thesis Page 118
Figure 5. 5: Available Paid and Open Source Testing tools Ph.D. Thesis Page 119
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 Speci Plan1 REgu represent the requirements supports Speci represent the management of specifications 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 Unito Funcn Load1 It supports automated ways and product of testing drivers It indicated the tool used for Unit testing It indicated the tool used for functional testing It indicated the tool used for Load testing Stress1 It indicated the tool used for Stress testing Ph.D. Thesis Page 119
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 a u n t u o a l U n i t F u n c L o a d P e r f Free XQual QAManager Salome TMF Test Case Web Testitools TestLink TestMaster Rth CodeSourcery Concordion STAF JUnit CUnit CppUnit XStudio QAManager Salome TMF Test Case Web Testitools TestLink TestMaster Rth QMtest Concordion STAFF JUnit CUnit CppUnit Ph.D. Thesis Page 120
PhpUnit HTMLUnit XHTMLUnit HTTPUnit Google JWebUnit Windmill JFunc Testing Anywhere The Grinder OpenWebLoad FWPTT OpenSTA Curl Loader AutoIt AutoHotkey Marathon Java.net Abbot GUITAR PhpUnit HTMLUnit XHTMLUnit HTTPUnit WebDriver JWebUnit Windmill JFunc Testing Anywhere The Grinder OpenWebLoad FWPTT OpenSTA Curl Loader AutoIt AutoHotkey Marathon Jemmy Abbot Abbot Ph.D. Thesis Page 121
Expect QAliber Tigris VNCRobot OpenQA Expect QAliber MBT VNCRobot Selenium Frankenstein Bromine Squash Magnetic Reason WatiN Watir CubicTest Telerik JBehave StoryTestIQ TextTest Cucumber SpecFlow Twist Sahi Squash FitNium WatiN Watir CubicTest WebAii Framework JBehave StoryTestIQ TextTest Cucumber SpecFlow Twist Sahi Ph.D. Thesis Page 122
Hammerhead The Grinder Pylot OpenSTA OpenLoad WebLoad JCrawler Hammerora DieselTest CLIF JMeter SIPr SIPp pjsip Hammerhead2 Grinder Pylot OpenSTA OpenWebLoad WebLoad JCrawler Hammerora DieselTest CLIF JMeter SIPr SIPp pjsua Commercial HP (formerly Mercury) HP Quality Center (formerly TestDirector) HP QuickTestPro (formerly QuickTest) HP WinRunner (WinRunner) HP LoadRunner (LoadRunner) Compuware QADirector Ph.D. Thesis Page 123
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 Microsoft UTest Parasoft TestPad TFS Test Manager (VSTT) UTest JTest C++Test WebKing T-Plan Verisium T-Plan Professional vmanage vtest vperformer Ph.D. Thesis Page 124
Seapine TestTrack TCM TestTrack Studio QA Wizard Pro APTest PassMark Software Gurock Software Conformiq APTestManager TestLog TestRail Qtronic SG Qtronic GP MKS Original Software MKS Integrity Qualify TestBench TestDrive TestDrive Assist TestMasters Zephyr Ken TestMan CodeSourcery Inflectra Prima Software Solutions Tricentis TMS Zephyr Ken TestMan QMtest SpiraTest JITE (plugin for JIRA) TOSCA Testsuite Ph.D. Thesis Page 125
JadeLiquid Software SmarteSoft LiquidTest SmartQM SmartScript SmartLoad TestOptimal LordUI Objentis mjtnet TechExcel InformUP ID Consultants @YourSide Consulting Testuff CatchLimited TOMOS PractiTest QMetry ITCampus DigitalTester Polarion TestOptimal LordUI QAS.TCS Macro Scheduler DevTest TestUP DuxQA ATD Testuff Enterprise Tester TOMOS PractiTest QMetry Web2Test DigitalTester Polarion Ph.D. Thesis Page 126
GenieSys TestRun TestWave OpenGroup FrogLogic Ranorex Dartenium Badboy iopus soapui InCisif.net Minq Software GenieTCMS TestRun TestWave TET Squish Ranorex Dartenium Badboy + Wave Test Manager imacros soapui InCisif.net PureTest PureLoad PureAgent Quotium AutomatedQA Elvior QTest TestComplete MessageMagic XML-simulator SoftwareResearch DurableSoftware TestWorks TestManager Ph.D. Thesis Page 127
Webius Software Wintask Origsoft SWExplorerAutomation Wintask Testdrive Gold Testdrive Assist software Plan9 ITKO for Qualify LISA Microsoft VisualStudio 2008 Orcanos SoftLogica QPack WAPT Exept AG Telerik Software Expecco ExpeccoNET WebUI Test Studio SmartBear QAComplete DevComplete Zeta Test S3 Zeta Test Stormtest Ph.D. Thesis Page 128
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 Supported Ranorex Studio ( Chrome, Firefox, Safari, IE ) Suppor ted C#, NET VB. Support ed Suppor ted Suppo rted Suppo rted 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 ( IE, Firefox, Chrome ) Suppor ted VBScript, JScript, C++Script, C#Script, DelphiScr ipt Support ed Suppor ted Suppo rted Suppo rted TOSCA Testsuite Supported ( IE, Firefox ) Suppor ted Java, C#, VB6 Support ed Suppor ted Suppo rted Suppo rted WatiN Supported ( IE ) Suppor ted C#, ability to run JavaScript from C# calls IE/FF Suppo rted Suppo rted Watir Supported ( IE, Firefox ) Suppor ted Ruby Support ed Suppor ted Suppo rted Suppo rted Ph.D. Thesis Page 129
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. Comprehensive testing is impossible. Ph.D. Thesis Page 130
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 Function RCB( ByValObj As FaultTolerance1 ) As Boolean Ph.D. Thesis Page 131
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 return ( TRUE ) Ph.D. Thesis Page 132
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 Ph.D. Thesis Page 133
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 If i< right Then ( pass parameter as right to procedure ) Ph.D. Thesis Page 134
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 Ph.D. Thesis Page 135
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 Time 9971 8971 9971 Ph.D. Thesis Page 136
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. Ph.D. Thesis Page 137
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, Ph.D. Thesis Page 138
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. Ph.D. Thesis Page 139
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. Ph.D. Thesis Page 140
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 Ph.D. Thesis Page 141
different stage, possible. the forecasting of faults in reference to specific system can be 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. Ph.D. Thesis Page 142
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. Ph.D. Thesis Page 143
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. Ph.D. Thesis Page 144
5.12 RESULT AND DISCUSSION OF PROPOSED SOFTWARE FAULT TOLERANCE MODEL As discussed earlier in 4 th 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. Ph.D. Thesis Page 145
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 Ph.D. Thesis Page 146
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 ). Figure 5. 10: Reliability and Fault Forecasting SFT Model Ph.D. Thesis Page 147
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. Ph.D. Thesis Page 148
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. Ph.D. Thesis Page 149
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 Ph.D. Thesis Page 150
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 Ph.D. Thesis Page 151
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, Ph.D. Thesis Page 152
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. Ph.D. Thesis Page 153
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. Ph.D. Thesis Page 154
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 ); string datatype = string _ Empty; Ph.D. Thesis Page 155
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; if ( txtinput2 _ Text _ Trim( )!= "" ) Ph.D. Thesis Page 156
Data To Be Sorted[1] = txtinput2 _ Text; if ( txtinput3 _ Text _ Trim( )!= "" ) datatobesorted[2] = txtinput3 _ Text; if ( txtinput4 _ Text _ Trim( )!= "" ) datatobesorted[3] = txtinput4 _ Text; if ( txtinput5 _ Text _ Trim( )!= "" ) datatobesorted[4] = txtinput5 _ Text; private int CountInputs( ) int totalinputs = 0; if ( txtinput1 _ Text _ Trim( )!= "" ) totalinputs++; if ( txtinput2 _ Text _ Trim( )!= "" ) totalinputs++; Ph.D. Thesis Page 157
if ( txtinput3 _ Text _ Trim( )!= "" ) totalinputs++; if ( txtinput4 _ Text _ Trim( )!= "" ) totalinputs++; if ( txtinput5 _ Text _ Trim( )!= "" ) totalinputs++; return totalinputs; private void SetOutputValue( object[] sorteddata ) if ( sorteddata!= null ) if ( sorteddata[0]!= null ) txtoutput1 _ Text = sorteddata[0] _ ToString( ); if ( sorteddata[1]!= null ) txtoutput2 _ Text = sorteddata[1] _ ToString( ); if ( sorteddata[2]!= null ) txtoutput3 _ Text = sorteddata[2] _ ToString( ); Ph.D. Thesis Page 158
if ( sorteddata[3]!= null ) txtoutput4 _ Text = sorteddata[3] _ ToString( ); if ( sorteddata[4]!= 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( ); Ph.D. Thesis Page 159
Ph.D. Thesis Page 160
<?xml version="1 _ 0" encoding="utf-8"?> <Project ToolsVersion="4 _ 0" DefaultTargets="Build" xmlns="http: / / schemas _ microsoft _ com/developer/msbuild/2003"> <Group of Property Define> <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> Ph.D. Thesis Page 161
<RootNamespace>Fault _ Tolerance _ SmartHandling _ Test</RootNamespace> <Name of AssemblUsed>Fault Tolerance Smart _ Handling Test </ Name of AssemblUsed > <Name of TVersion of Target Framework>v4 _ 0</ Name of TVersion of Target Framework > <Name of File _ Alignment>512</ Name of File _ Alignment > <Guide of Project Type>3AADDGHG-VBH-HJ-HJ-C096D0-AHG1C2-EFG12C- 1390-A83SD35FG801FGFDAB;FAEDFDF04EC0-3FDF01F-11DFD3SD- GHHGHBF4B-00C04GHFHJ79EGTCHFBC</ Guide of Project Type > </Group presentative of Property> < Group presentative of Property Condition=" '$( Configuration ) $( Platform )' == 'Debug AnyCPU' "> <Debug group presentative of Property Symbols>true</Debug group presentative of Property Symbols> <Debug number Type>full</Debug number Type> <Optimize parameter>false</optimize parameter > < parameter OutputPath>bin \ Debug \ </ parameter OutputPath> <Define parameter Constants>DEBUG;TRACE</Define parameter Constants> <Error bug Report desc >prompt</ Error bug Report desc > <Warning _ Greeb _ Level Dis>4</ Warning _ Greeb _ Level Dis > </PropertyGroup> <PropertyGroup Condition=" '$( Configuration ) $( Platform )' == 'Release AnyCPU' "> <DebugType>pdbonly</DebugType> <Optimize>true</Optimize> <OutputPath>bin \ Release \ </OutputPath> <DefineConstants>TRACE</DefineConstants> <ErrorReport>prompt</ErrorReport> <WarningLevel>4</WarningLevel> </ Group of Property Define > <Item Group of Property Define g > Ph.D. Thesis Page 162
<Reference Include="Microsoft _ Visual tool Studio _ For Quality Tools N Unit Test Framework, Version=10 _ 0 _ 0 _ 0, Culture = neutral, Public KeyT oken = b03f5fu7f11d35i50a3a, processor Architecture = MSIL" /> <Reference Include="System ( namespace )" /> <Reference Include="System _ Core ( namespace )"> <Required _ Target _ Framework > 3 _ 5 < / Required _ Target _ Framework > </Reference> </Item Group g> <Item Group f> <Code Analysis of Dependent Assembly Paths( location ) Condition=" '$( VS10rt0COMN NTOOL!S )'! = '' JGB78KG45HSD" Include="$ ( VS10rt0C OMNNTOLOLS ) \ I DE \ Private Assemblies"> <Visible ojbect >False</ Visible object> </ Code of Analysis _ for Dependent on _ Assembly _ ( location ) Paths> </ Item Group f > < Item Group e > < Include Compile ( file ) ="FaultToleranceTest _ cs" /> < Include Compile I ( file ) ="Properties \ AssemblyInfo _ cs" /> < Include Compile e ( file )="TestHelper _ cs" /> </Item Group e> <Item Group i> <ProjectReference Include=" \ Fault _ Tolerance _ Sorting _ Lib \ Fault _ Tolerance _ Sorting _ Lib _ csproj"> <Project>352F1BEC-9E6B-4F02-AC63-BD64C64DA082</Project> <Name>Fault _ Tolerance _ Sorting _ Lib</Name> </ProjectReference> </ Item Group i> <Import Project = "$ ( MS _ Build _ Bin _ Path( LOCATION ) ) \ Microsoft _ CSharp _ targets" /> <!-- To modify application which is already build process for the Other similar additional tin position survive, see Microsoft _ Common _ Targets for futher information Ph.D. Thesis Page 163
<Name of Target= "Beforeapp Build"> < _ / Target _ > < Name of Target = "Afterapp Build"> < _ /Target _ > --> ( Include ) using ( namespace ) System ; ( Include )using ( namespace ) System _ Text ; ( Include ) using ( namespace ) System _ Collections _ Generic ; ( Include ) using ( namespace ) System _ Linq ; ( Include ) using ( namespace ) Microsoft _ Visual Studio _ Test Tools _ Unit Testing ; ( Include ) using ( namespace ) Fault _ Tolerance _ Sorting _ Lib ; namespace Fault _ Tolerance _ SmartHandling _ Test [class creation about the Test Class] public class FaultToleranceTest [method creation about the TestMethod] public void SortInteger( ) object[] testdata = new object[5] 10, 3, 42, 24, 21 ; object[] expecteddata = new object[5] 3, 10, 21, 24, 42 ; SortingHelper sorting = new SortingHelper( ); object[] actualdata = sorting _ SortData( testdata, "int" ); Assert _ IsTrue( TestHelper _ CompareData( actualdata, expecteddata ) ); [TestMethod] public void SortDouble( ) object[] testdata = new object[5] 10 _ 2, 3 _ 1, 42 _ 0, 42 _ 1, 21 _ 7 ; Ph.D. Thesis Page 164
object[] expecteddata = new object[5] 3 _ 1, 10 _ 2, 21 _ 7, 42 _ 0, 42 _ 1 ; SortingHelper sorting = new SortingHelper( ); object[] actualdata = sorting _ SortData( testdata, "double" ); Assert _ IsTrue( TestHelper _ CompareData( actualdata, expecteddata ) ); [TestMethod] public void SortString( ) object[] testdata = new object[5] "India", "Pakistan", "Bangladesh", "Bhutan", "America" ; object[] expecteddata = new object[5] " America ", " Bangladesh ", "Bhutan", "India", "Pakistan" ; SortingHelper sorting = new SortingHelper( ); object[] actualdata = sorting _ SortData( testdata, "string" ); Assert _ IsTrue( TestHelper _ CompareData( actualdata, expecteddata ) ); [TestMethod] public void SortIntegerDoubleMix( ) object[] testdata = new object[5] 10, 3 _ 1, 42 _ 5, 24, 21 ; object[] expecteddata = new object[5] 3 _ 1, 10, 21, 24, 42 _ 5 ; SortingHelper sorting = new SortingHelper( ); object[] actualdata = sorting _ SortData( testdata, "int" ); Assert _ IsTrue( TestHelper _ CompareData( actualdata, expecteddata ) ); [TestMethod] public void SortDoubleStringMix( ) object[] testdata = new object[5] "Asia", 5, 42 _ 0, 42 _ 1, 21 _ 7 ; object[] expecteddata = new object[5] 21 _ 7, 42 _ 0, 42 _ 1, 5, "Asia" ; SortingHelper sorting = new SortingHelper( ); Ph.D. Thesis Page 165
object[] actualdata = sorting _ SortData( testdata, "double" ); Assert _ IsTrue( TestHelper _ CompareData( actualdata, expecteddata ) ); ( Include )using ( namespace ) System ; ( Include )using ( namespace ) System _ Collections _ Generic ; ( Include )using ( namespace ) System _ Linq ; ( Include )using ( namespace ) System _ Text ; namespace Fault _ Tolerance _ SmartHandling _ Test class TestHelper public static bool CompareData( object[] actualdata, object[] expecteddata ) bool issame = true; if( actualdata _ Length!= expecteddata _ Length ) return false; for( int i=0; i< expecteddata _ Length;i++ ) if ( actualdata[i] _ ToString( )!= expecteddata[i] _ ToString( ) ) return false; return true; ( Include ) using ( namespace ) System ; ( Include ) using ( namespace ) System _ Collections _ Generic ; Ph.D. Thesis Page 166
( Include ) using ( namespace ) System _ Linq ; ( Include ) using ( namespace ) System _ Text ; namespace Fault _ Tolerance _ Sorting _ Lib public class FaultHandler FaultToleranceException _ faultexception = null; public FaultHandler( FaultToleranceException faultexception ) this faultexception = faultexception; public object[] HandleFault( ) object[] sorteddata = new Object[ _ faultexception _ DataToBeSorted _ Length]; string datatypeforsorting = GetDataTypeForSorting( _ faultexception _ DataType ); ); switch ( datatypeforsorting _ ToLower( ) ) case "double": SortDoubles sortdouble = new SortDoubles( ); sorteddata = sortdouble _ SortData( _ faultexception _ DataToBeSorted break; case "string": string[] data = new string[ _ faultexception _ DataToBeSorted _ Length]; for( int i=0; i< _ faultexception _ DataToBeSorted _ Length; i++ ) Ph.D. Thesis Page 167
data[i] = _ faultexception _ DataToBeSorted[i] _ ToString( ); SortString sortstring = new SortString( ); sorteddata = data _ Select( x => ( object )x ) _ ToArray( ); sorteddata = sortstring _ SortData( sorteddata ); break; return sorteddata; private string GetDataTypeForSorting( string datatype ) double num; string datatypeforsorting = string _ Empty; if ( datatype _ ToLower( ) == "int" ) datatypeforsorting = "double"; for ( int i = 0; i < _ faultexception _ DataToBeSorted _ Length; i++ ) if (!Double _ TryParse( _ faultexception _ DataToBeSorted[i] _ ToString( ), out num ) ) datatypeforsorting = "string"; else if ( datatype _ ToLower( ) == "double" ) datatypeforsorting = "string"; return datatypeforsorting; Ph.D. Thesis Page 168
( Include ) using ( namespace ) System ; ( Include ) using ( namespace ) System _ Collections _ Generic ; ( Include ) using ( namespace ) System _ Linq ; ( Include ) using ( namespace ) System _ Text ; namespace Fault _ Tolerance _ Sorting _ Lib // This class is used to generate the Fault exception public class FaultToleranceException : Exception public object[] DataToBeSorted get; set; public string DataType get; set; public FaultToleranceException( object[] datatobesorted, string datatype, string message ) : base( message ) this _ DataToBeSorted = datatobesorted; this _ DataType = datatype; ( Include ) using ( namespace ) System ; ( Include ) using ( namespace ) System _ Collections _ Generic ; ( Include ) using ( namespace ) System _ Linq ; ( Include ) using ( namespace ) System _ Text ; namespace Fault _ Tolerance _ Sorting _ Lib class SortInteger public object[] SortData( object[] data ) int num; Ph.D. Thesis Page 169
int[] datatobesorted = new int[data _ Length]; //Throw custom fault exception if the data is not of type int for ( int i = 0; i < data _ Length; i++ ) if (!Int32 _ TryParse( data[i] _ ToString( ), out num ) ) throw new FaultToleranceException( data, "int", "Not a valid data for Int" ); datatobesorted[i] = num; // Sorting integer data Array _ Sort( datatobesorted ); // Converting int array to object array to make it generic object[] sorteddata = datatobesorted _ Select( x => ( object )x ) _ ToArray( ); return sorteddata; ( Include ) using ( namespace ) System ; ( Include ) using ( namespace ) System _ Collections _ Generic ; ( Include ) using ( namespace ) System _ Linq ; ( Include ) using ( namespace ) System _ Text ; namespace Fault _ Tolerance _ Sorting _ Lib class SortString public object[] SortData( object[] data ) try Ph.D. Thesis Page 170
Array _ Sort( data ); catch ( Exception ex ) return data; this _ Btn Sort _ Back Color = System _ Drawing _ Color _ Orange ( set the color ); this _ btn Sort _ Font = new System _ Drawing _ Font ( " Moire ", 9 _ 75 F ); this _ btn Sort _ Location = new System _ Drawing _ Poin t ( 4 1 7, 130 ); this _ Btn Sort _ Name = "btn Sort"; this _ Btn Sort _ Size = new System _ Drawing _ Size ( 86, 28 ); this _ btn Sort _ TabIndex = 8; this _ Btn Sort _ Text = "Sort Data"; this _ Btn Sort _ Use Visual Style Back Color = false; this _ Btn Sort _ Click += new System _ Event Handler ( this _ Btn Sort _ Click ); // // grpoutput // this _ grpoutput _ BackColor = System _ Drawing _ Color _ PaleGoldenrod; this _ grp Output _ Controls _ CTR _ Add( this* _ txt Output2 ); this _ Grp Output _ Controls CTR _ Add( this* _ Lbl Output2 ); this _ Grp Output _ Controls _ CTR _ Add( this* _ txt Output3 ); Ph.D. Thesis Page 171
); this _ Grp Output _ Controls _ CTR _ Add( this* _ l bloutput3 ); this _ Grp Output _ Controls CTR _ Add( this* _ t xtoutput4 ); this _ Grp Output _ Controls CTR _ Add( this* _ lbloutput4 ); this _ Grp Output _ Controls _ Add ( this* _ txtoutput5 ); this _ Grp Output _ Controls _ Add ( this* _ lbloutput5 ); this _ Grp Output _ Controls _ Add this* _ txtoutput1 ); this _ Grp Output _ Controls _ Add this* _ lbloutput1 ); this _ Grp Output _ Font = new System _ Drawing _ Font( "Moire", 9 _ 75F this _ Grp Output _ Location = new System _ Drawing _ Point( 513, 30 ); this _ Grp Output _ Name = "grpoutput"; this _ grpoutput _ Size = new System _ Drawing _ Size( 257, 191 ); this _ grpoutput _ TabIndex = 1; this _ grpoutput _ TabStop = false; this _ grpoutput _ Text = "Output of Sorting"; // // txtoutput2 // this _ txtoutput2 _ Enabled = false; this _ txtoutput2 _ Location = new System Drawing Point( 89, 65 ); this _ txtoutput2 _ Name = "txtoutput2"; this _ txtoutput2 _ Size = new System Drawing Size( 143, 23 ); this _ txtoutput2 _ TabIndex = 19; // // lbloutput2 // this _ lbloutput2 _ AutoSize = true; this _ lbloutput2 _ Location = new System _ Drawing _ Point( 15, 68 ); this _ lbloutput2 _ Name = "lbloutput2"; this _ lbloutput2 _ Size = new System _ Drawing _ Size( 69, 15 ); this _ lbloutput2 _ TabIndex = 18; this _ lbloutput2 _ Text = "Output 2 :"; Ph.D. Thesis Page 172
// // txtoutput3 // this _ txtoutput3 _ Enabled = false; this _ txtoutput3 _ Location = new System _ Drawing _ Point( 89, 91 ); this _ txtoutput3 _ Name = "txtoutput3"; this _ txtoutput3 _ Size = new System _ Drawing _ Size( 143, 23 ); this _ txtoutput3 _ TabIndex = 17; // // lbloutput3 // this _ lbloutput3 _ AutoSize = true; this _ lbloutput3 _ Location = new System _ Drawing _ Point( 15, 94 ); this _ lbloutput3 _ Name = "lbloutput3"; this _ lbloutput3 _ Size = new System _ Drawing _ Size( 69, 15 ); this _ lbloutput3 _ TabIndex = 16; this _ lbloutput3 _ Text = "Output 3 :"; // // txtoutput4 // this _ txtoutput4 _ Enabled = false; this _ txtoutput4 _ Location = new System _ Drawing _ Point( 89, 117 ); this _ txtoutput4 _ Name = "txtoutput4"; this _ txtoutput4 _ Size = new System _ Drawing _ Size( 143, 23 ); this _ txtoutput4 _ TabIndex = 15; // // lbloutput4 // this _ lbloutput4 _ AutoSize = true; this _ lbloutput4 _ Location = new System _ Drawing _ Point( 15, 120 ); this _ lbloutput4 _ Name = "lbloutput4"; this _ lbloutput4 _ Size = new System _ Drawing _ Size( 69, 15 ); Ph.D. Thesis Page 173
this _ lbloutput4 _ TabIndex = 14; this _ lbloutput4 _ Text = "Output 4 :"; / / / / txtoutput5 / / this _ txtoutput5 _ Enabled = false; this _ txtoutput5 _ Location = new System _ Drawing _ Point( 89, 143 ); this _ txtoutput5 _ Name = "txtoutput5"; this _ txtoutput5 _ Size = new System _ Drawing _ Size( 143, 23 ); this _ txtoutput5 _ TabIndex = 13; / / / / lbloutput5 / / this _ lbloutput5 _ AutoSize = true; this _ lbloutput5 _ Location = new System _ Drawing _ Point( 15, 146 ); this _ lbloutput5 _ Name = "lbloutput5"; this _ lbloutput5 _ Size = new System _ Drawing _ Size( 69, 15 ); this _ lbloutput5 _ TabIndex = 12; this _ lbloutput5 _ Text = "Output 5 :"; / / / / txtoutput1 / / this _ txtoutput1 _ Enabled = false; this _ txtoutput1 _ Location = new System _ Drawing _ Point( 89, 39 ); this _ txtoutput1 _ Name = "txtoutput1"; this _ txtoutput1 _ Size = new System _ Drawing _ Size( 143, 23 ); this _ txtoutput1 _ TabIndex = 11; / / / / lbloutput1 / / this _ lbloutput1 _ AutoSize = true; this _ lbloutput1 _ Location = new System _ Drawing _ Point( 15, 42 ); Ph.D. Thesis Page 174
this _ lbloutput1 _ Name = "lbloutput1"; this _ lbloutput1 _ Size = new System _ Drawing _ Size( 69, 15 ); this _ lbloutput1 _ TabIndex = 10; this _ lbloutput1 _ Text = "Output 1 :"; / / / / lblerrordisplay / / this _ lblerrordisplay _ AutoSize = true; this _ lblerrordisplay _ Font = new System _ Drawing _ Font( "Moire", 9 _ 75F ); this _ lblerrordisplay _ ForeColor = System _ Drawing _ Color _ Red; this _ lblerrordisplay _ Location = new System _ Drawing _ Point( 26, 239 ); this _ lblerrordisplay _ Name = "lblerrordisplay"; this _ lblerrordisplay _ Size = new System _ Drawing _ Size( 113, 15 ); this _ lblerrordisplay _ TabIndex = 11; this _ lblerrordisplay _ Text = "Error To Display"; this _ lblerrordisplay _ Visible = false; / / / / btncleardata / / this _ btncleardata _ BackColor = System _ Drawing _ Color _ Orange; this _ btncleardata _ Font = new System _ Drawing _ Font( "Moire", 9 _ 75F ); this _ btncleardata _ Location = new System _ Drawing _ Point( 417, 88 ); this _ btncleardata _ Name = "btncleardata"; this _ btncleardata _ Size = new System _ Drawing _ Size( 86, 28 ); this _ btncleardata _ TabIndex = 12; this _ btncleardata _ Text = "Clear Data"; this _ btncleardata _ UseVisualStyleBackColor = false; this _ btncleardata _ Click += new System _ EventHandler( this _ btncleardata _ Click ); Ph.D. Thesis Page 175
/ / / / frmfaulttolerance / / Font; this _ AutoScaleDimensions = new System _ Drawing _ SizeF( 6F, 13F ); this _ AutoScaleMode = System _ Windows _ Forms _ AutoScaleMode _ this _ BackColor = System _ Drawing _ Color _ LemonChiffon; this _ ClientSize = new System _ Drawing _ Size( 794, 268 ); this _ Controls _ Add( this _ btncleardata ); this _ Controls _ Add( this _ lblerrordisplay ); this _ Controls _ Add( this _ grpoutput ); this _ Controls _ Add( this _ btnsort ); this _ Controls _ Add( this _ grpinput ); this _ Name = "frmfaulttolerance"; this _ Text = "Smart Fault Handling"; this _ Load += new System _ EventHandler( this _ Form1 _ Load ); this _ grpinput _ Resume Layout( false ); this _ grpinput _ PerformLayout( ); this _ groupbox1 _ Resume Layout( false ); this _ groupbox1 _ PerformLayout( ); this _ grpdatatype _ Resume Layout( false ); this _ grpdatatype _ PerformLayout( ); this _ grpoutput _ Resume Layout( false ); this _ grpoutput _ PerformLayout( ); this _ Resume Layout( false ); this _ Perform Layout( ); Ph.D. Thesis Page 176
The proposed ways to ensure and make BI-VER more reliable as, independence through version independence Use diverse people to develop the different versions Use different development processes to develop the different versions Use different technology, tools, programming languages, methodologies, etc _ to develop the different versions Fix number of version will save cost and programming efforts Fix number of version use for getting required results Fix number and restarting the same version will reduce the code _ It will manage redundancy from requirements specification to interface implementation _ Dealing with uncharacteristic situation arising in the environment Enable program in such manner so that system design faults must be tolerated Provide an error-detection and recovery facility Ph.D. Thesis Page 177