Search

Recent years have seen the utilisation of Semantic Web Service descriptions for automating a wide range of service-related activities, with a primary focus on service discovery, composition, execution and mediation. An important area which so far has received less attention is service validation, whereby advertised services are proven to conform to required behavioural specifications. This paper proposes a method for validation of service-oriented systems through automated functional testing. The method leverages ontology-based and rule-based descriptions of service inputs, outputs, preconditions and effects (IOPE) for constructing a stateful EFSM specification. The specification is subsequently utilised for functional testing and validation using the proven Stream X-machine (SXM) testing methodology. Complete functional test sets are generated automatically at an abstract level and are then applied to concrete Web services, using test drivers created from the Web service descriptions. The testing method comes with completeness guarantees and provides a strong method for validating the behaviour of Web services.

A study from the Business Internet Group San Francisco (BIG-SF) reported approximately 70% of websites contain bugs (resided in both static pages and dynamic pages) and suffer some kind of failure. Interestingly, these sites include not only commercial websites but also US government managed websites. It is our objective to better understand why testers are unable to reveal certain kind of bugs. We have reviewed several testing methods, summarized their techniques, and listed the kinds of problems that can or cannot be tested. Consequently, we suggest a complementary solution by re-using the existing methods for web applications testing that may prove fruitful.

Demand for high‐quality Web applications continues to escalate as reliance on Web‐based software increases and Web systems become increasingly complex. Given the importance of quality and its impact on the user experience, a significant research effort has been invested in developing tools and methodologies that facilitate effective quality assurance for Web applications. Testing, in particular, provides a critical inroad toward meeting the quality demand by enabling developers to discover failures and anomalies in applications before they are released. In this survey, we discuss advances in Web testing and begin by exploring the peculiarities of Web applications that makes evaluating their correctness a challenge and the direct translation of conventional software engineering principles impractical in some cases. We then provide an overview of research contributions in three critical aspects of Web testing: deriving adequate Web application models, defining appropriate Web testing strategies, and conducting Web portability analysis. In short, models are used to capture Web application components, their attributes, and interconnections; testing strategies use the models to generate test cases; and portability analysis enables Web developers to ensure that their applications remain correct as they are launched in highly diverse configurations.

In this paper the problems in the automation testing of GUI based Web applications are discussed. A new automation testing framework based on the concept of object feature set and dynamic searching policy is proposed. The design and implementation of it are both given. The framework working using result shows that it makes the testing more convenient and efficient with less resources and time cost but higher testing coverage.The ability of maintenance and stability are both improved.

The application of a model-driven paradigm in the development of Web Systems has yielded very good research results. Several research groups are defining metamodels, transformations, and tools which offer a suitable environment, known as model-driven Web engineering (MDWE). However, there are very few practical experiences in real Web system developments using real development teams. This chapter presents a practical environment of MDWE based on the use of NDT (navigational development techniques) and Java Web systems, and it provides a practical evaluation of its application within a real project: specialized Diraya. Ministerio de Educación y Ciencia TIN2007-67843-C06-03 Ministerio de Educación y Ciencia TIN2007-30391-E

Testing to ensure service QoS is a key problem for Web Service adoption. One of the key problems for software testing is designing the finite test suit tailored to test case generation efficiently. This paper focuses on Abstract Test Suite and Executable Test Suite analysis of WSDL_based Web Service and proposes automated WSDL_based Web Service testing. A XML_based test scripting language is discussed and Executable Test Suite can be derived from Abstract Test Suite automatically based on XML parser. Executable Test Suite consists of message Schema syntactic test group, Web Service interface test group, and interoperation test group. A test process is used in WSDL_based Web Service testing. The three key techniques adopted by the test process including the test case generation, test flow, and test data generation are analyzed.

This paper presents a novel information sharing framework using Service-Oriented Database System (SODB) for service registry and repository that facilitates data integration. A SODB is a database architecture composed with reusable services to support searching, querying, deleting, and storing data. As SODB is organized in a service-oriented manner, SODB can be easily changed or maintained by reusing different services. Thus, it can be used to share information in the cloud. The Information Sharing System (ISS) component of the SODB employs domain ontology to share data sources. The domain ontology utilizes mathematical equivalence relations to map data sources into appropriate domain ontology. It also facilitates dynamic query composition across data sources. This paper also presents the design, implementation, and performance evaluation of the ISS component. Our implementation is based on a real application, the Arizona Healthcare Cost Containment System (AHCCCS). This application demonstrates that the ISS can facilitate complex information integration. Finally, this paper presents the performance of the ISS using WAPT (Web Application Testing) for Microsoft Windows XP, and the response time consistently fall in between 0.1 to 0.15 second for each request.

In this paper, we first introduce the concepts of mobile agent technology, and then look at some related research on mobile agent technology. Mobile agent is a promising technology to face the problems raised by the increasing complexity and size of today’s networks and web testing. In particular, in the area of web testing, mobile agent can lead to a fully distributed paradigm to overcome the limits of traditional web testing methods. Next we study the issues about web testing include load testing, stress testing, security testing, reliability testing. In addition, we link these four factors to today’s websites, and study how we can examine the quality functionalities of websites. Finally, we combine the verdicts from different sections of this paper and propose models that utilize mobile agent technology for performing different aspects of web testing.

Web automation applications are widely used for different purposes such as B2B integration, automated testing of web applications or technology and business watch. One crucial part in web automation applications is to allow easily generating and reproducing navigation sequences. Previous proposals in the literature assumed a navigation model today turned obsolete by the new breed of AJAX-based websites. Although some open-source and commercial tools have also addressed the problem, they show significant limitations either in usability or their ability to deal with complex websites. In this paper, we propose a set of new techniques to deal with this problem. Our main contributions are a new method for recording navigation sequences supporting a wider range of events, and a novel method to detect when the effects caused by a user action have finished. We have evaluated our approach with more than 100 web applications, obtaining very good results.

Mobile Web usability is a measure of how easy (or otherwise) a user finds it to interact with a web site through a mobile device. In this chapter we look at some of the most heavily used Mobile Web sites and show you how to apply best practices and design guidelines to create an effective web site for a mobile device.

The paper proposes a new test model, Call-For-Testing (CFT), and applies it to User Acceptance Testing (UAT) of Web Applications. Different from traditional approaches, UAT in the context of CFT only means beta-testing on the site or field, i.e., by customers or end-users, and does not include alpha-testing which is supervised or performed by the system provider. CFT model leverages open community resources for UAT. To guarantee the quality of CFT-oriented UAT, not only do we develop competent testing techniques/tools for community testers to perform UAT, but also a testing auditing mechanism is built up. We develop a CFT platform that constructs coverage criteria based on user requirements and design documents, monitors community testers activities in real-time, and verifies their performances. Experiments are performed to evaluate the validity of CFT.

Database has been widely used in Web applications and database interactions influence the navigations of Web applications. Besides, database interactions are among the most essential functional features in current Web applications. In this paper, special care is taken on database interactions in modeling and testing Web applications. GFSMs (Guarded Finite State Machines), which are augmented FSMs are employed as a tool to model database interactions. A GFSM-TT(GFSM test-tree) is constructed from GFSM. From the test-tree, minimal test set is derived to be employed to generate test. Finally, an algorithm is designed to optimize the test paths by decreasing the overlap. The approach we proposed can yield substantial results with test paths and state transitions are all less.

Penetration testing is a widely used method for testing the security of web applications, but it can be inefficient if it is not done systematically. Public databases of web application vulnerabilities can be used to drive penetration testing, but testers need to understand them and interpret them into executable test cases. This requires an in-depth knowledge of security. This paper proposes a model-based testing approach using a data model that describes the relationship between web security knowledge, business domain knowledge, and test case development. The approach consists of a data model that represents the relevance between attack surface, application fingerprint, attack vectors, and fuzz vectors; a test case generator that automatically generates penetration test scenarios for web applications; and a penetration test framework supported by TTCN-3 test environment. The model-based testing approach can be used to provide structured tool support for developing penetration test campaigns. We demonstrate the feasibility and efficiency of the approach at the design level.

The main goal of Web application design is to facilitate the understanding of the solution that is going to be developed (i.e., the Web application), as opposed to the understanding of the users and the context in which the solution is deployed, which is addressed by requirements engineering. Web application design can be regarded as the set of activities that refine the abstractions identified during requirements analysis with the aim of specifying the organization of the application data, navigation, presentation, and architecture.

As you saw in the last chapter, writing code to communicate over a network can be complex and, at times, difficult. Fortunately, for many common network-related tasks, Apple has provided higher-level methods and objects that will make your life considerably easier. One fairly common task when you’re writing software for a device that’s pretty much always connected to the Internet is to retrieve data from web servers. There is a large amount of data available for applications to use on the World Wide Web, and there are countless reasons why an iPhone application might want to pull data from the Web.

E-government is innovation and change of administrative activities for hundreds of years. This paper proposed a E-government's Web mining method based on the Semantic Web. It first describes the Design and Implementation of the web spider, tool of colleting network data collection, including the basic structure of the work processes and procedures of the web spider, the storage structure and form web spider collected, the network topology discovery algorithms and the major technical difficulties and details of implementation of web spider. In actual test, the system runs effective and efficient. Finally this paper points out the works that need to improve and upgrade.

Web applications often use dynamic pages that interact with each other by accessing shared objects, e.g., session objects. Interactions between dynamic pages need to be carefully tested, as they may give rise to subtle faults that cannot be detected by testing individual pages in isolation. Since it is impractical to test all possible interactions, a trade-off must be made between test coverage (in terms of number of interactions covered in the tests) and test effort. In this paper, we present a test sequence generation approach to cover all pairwise interactions, i.e., interactions between any two pages. Intuitively, if a page P could reach another page Ppsila, there must exist a test sequence in which both P and Ppsila are visited in the given order. We report a test sequence generation algorithm and two case studies in which test sequences are generated to achieve pairwise interaction coverage for two Web applications. The empirical results indicate that our approach achieves good code coverage and is effective for detecting interaction faults in the subject applications.

As more and more services and information are made available over the Internet and Intranet, web portals are gaining in popularity and have become extraordinarily complex to test for their functionality. These web portals usually have thousands of hyper links, images, multimedia files, data files, audio files among many others. Web pages are modified frequently viz. adding links, making user specific customizations, adding new features and many other functionalities. Many a times these consist of hundreds of files of different types to be navigated by the users. Due to this, conventional software testing methods and tools are not adequate for these Web portals. In this paper, we propose an automated test tool which will test such a Web portal for all the missing links, file type mismatches, unreachable files etc. It also reports errors in Java Script and PHP modules embedded in the HTML documents. The tool will have a dry run to identify all these features and will generate a complete report regarding the web portal for the ease of maintenance. This tool is supposed to work on both static and dynamic Web pages. Dynamic content include filling up the forms, entering login information etc. This tool generates test cases for running over the web portal which uses regression testing techniques. It also provides GUI for easy interaction with the portal. The methodology used includes the global data flow analysis, use-definition chains, construction of control flow graph and regression testing.

The goal of my work is to improve quality assurance techniques for web applications. I will develop automated techniques for modeling web applications and use these models to improve testing and analysis of web applications.

New Web technologies, languages, and methodologies make it possible to create interactive applications that represent a new model frequently called Web 2.0 applications. This paper describes an approach to tracking user interaction with these applications. Our main motivation is to help developers run remote usability tests with a web 2.0 application and analyze the collected data. Tracking is done through AJAX techniques, in a non intrusive manner regarding the user. We present a tool, named Web Application Usage Tracking Tool (WAUTT), that implements the approach proposed. WAUTT was evaluated in a real usability test to show its usefulness.

New Web technologies, languages, and methodologies make it possible to create interactive applications that represent a new model frequently called Web 2.0 applications. This paper describes a tool, named Web Application Usage Tracking Tool (WAUTT), to tracking user interaction with these applications. Our main motivation is to help developers run remote usability tests with a web 2.0 application and analyze the collected data. Tracking is done through AJAX techniques, in a non intrusive manner regarding the user. WAUTT was evaluated in a real usability test to show its usefulness.

Controlled experiments in web application testing use seeded faults to evaluate the effectiveness of the testing technique. However, the classes of seeded faults are not always experimentally supported by real-world fault data. In this paper, we conduct an exploratory study on two large open source web systems to identify a fault classification that is representative of and supported by real world faults. Through our study we provide support to several categories of an existing web application fault classification, and identify one new fault category and six new sub-categories. Researchers and experimenters will find the proposed fault classification useful when evaluating techniques for testing web applications.

Nowadays companies and home users use Web sites offering services ranging from Web sites up to complex Web applications. Often the ergonomics of these applications remains unconsidered and they turn out to be hard to use. In order to examine the usability from within the Web applications, information about the usage of the application is collected. The techniques that have been used in the past for Web 1.0 are no longer adequate. Ajax programs (Web 2.0) are more flexible and require other techniques. This paper shows techniques for collection, analysis, processing and visualization of data for Web 2.0 applications.

Nowadays, the B/S-based e-commerce application mode has been more and more accepted by the people. In order to adapt to the increasingly complex needs of e-commerce marketing, the collection and analysis of Web user behaviors has been given more attention. This paper brings out a design idea of Ajax-based system that collects analyses and feedback the Web user behaviors. It then focuses on the method of Web user behavior collection, and discusses several schemes. Finally, based on these schemes, a simple test Web site is designed and implemented to have a 100 people small-scale test. The analysis of the test results approves the correctness of the method this paper brings out. At the end of this paper, it points out the guiding role to the actual production engineering application and the reference value to the research in other field of this method.

Automated tests are important for Web applications as they grow more complex day by day. Web application testing frameworks have emerged to help satisfy this need. However, used without a model that is designed for system evolution and realization, maintaining test code becomes cumbersome and inefficient. This paper describes an activity oriented approach to engineer automated tests for Web applications with reference to a Web application developed for grant funding agencies. In this approach, the developer defines a domain model to represent application state, and uses a test activity graph comprised of self-validating user interactions to verify application correctness. We have implemented a test code generator called iTester using activity-oriented approach.

Web applications are used extensively for a variety of critical purposes and, therefore, must be reliable. Since Web applications often contain large amounts of code and frequently undergo maintenance, testers need automated tools to execute large numbers of test cases to determine if an application is behaving correctly. Evaluating the voluminous output-typically Web pages full of content-is tedious and error-prone. To ease the difficulty, testers can apply automated oracles, which have tradeoffs in false positives and false negatives. In this paper, we present the design, implementation, and evaluation of WebVizOr, a tool that aids testers byapplying a set of oracles to the output from test cases and highlighting the symptoms of possible faults. Using WebVizOr, a tester can compare the test results from several executions of a test case and can more easily determine if a test case exposes a fault.

A web service exposes a public API that can be accessed by potentially hostile clients over the internet. Pex, a white-box test generation tool for .NET, can automatically create test inputs that cover comer cases of a web service implemented in .NET, simulating a malicous attacker.

TAV-WEB 2008 is the third in a series of workshops that focus on testing, analysis and verification of web software. The goal of these workshops has been to bring together researchers from academic, research, and industrial communities interested in the emerging area of dependable Web software development, to present and discuss their recent research results.

To ensure the requested quality of Web applications as expected, it is critical and challenging to test them. This work defines Web application schema and constructs Web application relation graph in order to model Web applications. An approach to generating test paths is presented by establishing path-generating graph which is derived from the Web application relation graph and used to produce path expressions. The test paths can be easily employed to construct test cases if user input values are provided. For illustration, a case study of the SWLS (Simple Web Login System) is exemplified. Moreover, a path generation strategy is suggested in accordance with the "divide and conquer" principle when the Web application under test is complicated. The strategy makes the Web application less complex and more controllable. This also restricts the state space explosion in a sense. The test path generation approach presented is an important supplement to the existing Web application testing.

Searching for Web service access points is no longer attached to service registries as Web search engines have become a new major source for discovering Web services. In this work, we conduct a thorough analytical investigation on the plurality of Web service interfaces that exist on the Web today. Using our Web Service Crawler Engine (WSCE), we collect metadata service information on retrieved interfaces through accessible UBRs, service portals and search engines. We use this data to determine Web service statistics and distribution based on object sizes, types of technologies employed, and the number of functioning services. This statistical data can be used to help determine the current status of Web services. We determine an intriguing result that 63% of the available Web services on the Web are considered to be active. We further use our findings to provide insights on improving the service retrieval process.

Cookies, the HTTP state management mechanism, are the backbone of many web applications. Despite a high adoption rate, cookies have remained virtually unexplored by the academic community. This paper presents an EBNF grammatical definition and a three- tiered testing strategy for cookies. The testing strategy builds upon anti-random and grammar-based methodologies examining cookies from three perspectives: cookies collections, individual cookie transformations and application-specific test-case generation. The collection of cookies maintained within a user-agent are explored in light of the anti-random test- suite reduction techniques and the grammatical definition of a cookie, culminating in the definition of a number of seeding test-vectors providing the basis for a scalable test-suite. A number of distinct grammatically correct cookie transformations are presented, providing further scalability to the proposed testing strategy. Finally a discussion of application-specific cookie transformations is presented, with focus upon the security and reliability concerns of modern web applications.

In this paper, we discuss a model based software testing method for testing of the Web applications using StateCharts. To this end, we briefly describe the test coverage technique, editorial tools for drawing StateCharts, modeling concurrency in Web applications, and test metrics. A simple Web application has been used to show the feasibility of our approach.

Web applications have rapidly become a critical part of business for many organizations. However, increased usage of Web applications has not been reciprocated with corresponding increases in reliability. Unique characteristics, such as quick turnaround time, coupled with growing popularity motivate the need for efficient and effective Web application testing strategies. In this paper, we propose several new test suite prioritization strategies for Web applications and examine whether these strategies can improve the rate of fault detection for three Web applications and their preexisting test suites. We prioritize test suites by test lengths, frequency of appearance of request sequences, and systematic coverage of parameter-values and their interactions. Experimental results show that the proposed prioritization criteria often improve the rate of fault detection of the test suites when compared to random ordering of test cases. In general, the best prioritization metrics either (1) consider frequency of appearance of sequences of requests or (2) systematically cover combinations of parameter-values as early as possible.

In this paper we propose an Automated Web application Testing (AWAT) system which can be used by instructors to effectively evaluate student web programming projects automatically based on the test cases specified on Excel. The AWAT is driven by WATIR and simulates the actions of human testers to extract information from Web pages, and verify expected outcome based on the test case specification. The system is unique in its ability to interact with web GUI and its portability to work with any client side or server side web application on any platforms.The preliminary experiments have been conducted and We found that the system can provide fairness to the grading of large scaled student projects and can greatly help elevate faculty productivity.

This paper proposes a practical test model and test approach for Web applications based on use cases and their corresponding sequence diagrams. Large Web applications are modeled as hierarchical profile use-case diagrams called UCTM (use case transition model). From the hierarchical UCTM, the sequential dependency relationship of use cases can be gained. Traversing the UCTM from top to down, each use case is described by sequence diagram, which can be converted automatically into a restricted message-on-vertex graph (RMOVG). A vertex in RMOVG represents one message in sequence diagram. To reduce the number of test cases generated, the constraint message coverage (CMC) criterion is proposed. According to the CMC criterion, each message in sequence diagram must be visited at least once. Test cases generated from RMOVG can satisfy CMC criterion and reduce the number of test cases. The proposed approach is a significant supplement to the existing Web application testing techniques.

syntax NavigationClass NavigationNode isLandmark : Boolean inheritance → inheritance among stereotypes repeated mapping of attributes and associations

One of the most well known and used approach to dynamically analyze a Web application requires to the user to analyze code and requirements of the application to extract its scenarios and the needed inputs. This information is used to exercise the application behavior and so build its model. Hence, high knowledge and effort are required to apply that kind of analysis. Moreover, it is well recognized that a dynamic approach builds partial models since it is strictly related to the application execution. In this paper, we talk about an approach that uses code mutation to reverse engineer a Web application and build its model then used for testing. We document an experiment done to evaluate feasibility and effectiveness of that approach comparing it with other traditional ones. The results show that the approach automatically builds models containing a limited degree of inaccuracy that can be pruned during the application testing.

To make function test of Web application based on struts automation, an automated test tool is proposed. The content of form is produced through analyzing Web page by HtmlParser. The test cases are produced by matching the data in test database and the content of form. The test cases are described by XML. Changing the test cases to code of Cactus and running the code to achieve the target of testing Web application.

Ajax supports the development of rich-client Web applications, by providing primitives for the execution of asynchronous requests and for the dynamic update of the page structure and content. Often, Ajax Web applications consist of a single page whose elements are updated in response to callbacks activated asynchronously by the user or by a server message. These features give rise to new kinds of faults that are hardly revealed by existing Web testing approaches. In this paper, we propose a novel state-based testing approach, specifically designed to exercise Ajax Web applications. The document object model (DOM) of the page manipulated by the Ajax code is abstracted into a state model. Callback executions triggered by asynchronous messages received from the Web server are associated with state transitions. Test cases are derived from the state model based on the notion of semantically interacting events. We evaluate the approach on a case study in terms of fault revealing capability. We also measure the amount of manual interventions involved in constructing and refining the model required by this approach.

Software testing is a challenging work and Web application testing may be even more challenging owing to its dynamic behaviors and heterogeneous representations. In this paper, we propose a static analysis approach to automatically generate test cases for Web application. In our approach, application source code is analyzed to extract interfaces which are composed of input parameters with domain information and user navigation map which is composed of all the possible URLs from Web application source code, then through the navigation graph, a set of paths is selected and test cases are generated for each path. Our approach is illustrated by analyzing a simplified login validation JSP page in a student information management system.

At present, most of Web applications have multi-tier architectures. The Web application contains many components, which makes it become component-based Web application. This paper focuses on this kind of Web applications and constructs three dependency graphs based on structure relations and message call relations. Then we improve the path-based integration testing method, propose an extended MM-path approach and use this approach to find out testing paths of component-based Web application.

This paper presents an approach to create adaptive web-based educative systems that can be automatically audited by means of standard web testing tools. The auditing tool takes the role of a learner interacting with the system, checking that no errors are present. The tool can communicate with the exercises to know the correct answers to them; a configurable ratio of correct to incorrect answers allows the tool to behave as a range of different students. More complex checking techniques will be tested in the future using this architecture. Refereed/Peer-reviewed

Surveying and classifying previous work in a particular field brings several benefits, which are to (a) help organise a given body of knowledge, (b) provide results that can help identify gaps that need to be filled, (c) provide a categorisation that can also be applied or adapted to other surveys, and (d) provide a classification and summary of results that may benefit practitioners and researchers who wish to carry out meta-analyses. This chapter presents a literature survey of size measures (attributes) that have been published since 1992 and classifies these measures according to a proposed taxonomy. We also discuss ways in which Web companies can devise their own size measures.

The use of web services has been growing significantly, with increasingly large numbers of applications being implemented through the web. A difficulty associated with this development is the quality assurance of these services, specifically the challenges encountered when testing the applications - amongst other things, testers may not have access to the source code, and the correctness of the output may not be easily ascertained known as the oracle problem. Metamorphic testing MT has been introduced as a technique to alleviate the oracle problem. MT makes use of properties of the software under test, known as metamorphic relations, and checks whether or not these relations are violated. Since MT does not require source code to generate the metamorphic relations, it is suitable for testing web services-based applications. We have designed an XML-based language representation to facilitate the formalisation of metamorphic relations, the generation of follow-up test cases, and the verification of the test results. Based on this, we have also developed a tool to support the automation of MT for web service applications. This tool has been used in an experiment to test web services, the evaluation of which is reported in this paper.

As an important method to ensure the quality of Web applications, Web testing attracts more and more attentions in the academic community and industrial world. Testing Web applications raises new problems and faces very high challenges. This work proposes a Web testing model for Web application testing. It starts from constructing the PFD (Page Flow Diagram) of the Web application. An algorithm is then designed to derive a PTT (Page Test Tree) from the PFD. From the PTT, a test translator is employed to extract the path expression, in order to generate all the test paths and then translates them into a test specification in XML syntax, which is the input of test engine. The test engine generates test cases and then executes them, and finally produces test report. The model presented is an important supplement to the existing Web application testing.

As Web sites becoming a fundamental component of businesses, quality of service will be one of the top management concerns. Users, normally, does not care about site failures, traffic jams, network bandwidth [1], or other indicators of system failures. To an online customer, quality of service means fast, predictable response service, level of a Web site noted in a real time. User measures the quality by response time, availability, reliability, predictability, and cost. Poor quality implies that the customer will no longer visit the site and hence the organization may loose business. The issues that affect the quality are broken pages and faulty images, CGI-bin error messages, complex colour combinations, no back link, multiple and frequent links, etc. So we try to build a good program that can scan Web site for broken links, broken images, broken pages and other common Web site faults. As Web site cannot test as a whole in one attempt we rely on decomposing the behavior of the Web site into testable components and mapping these components onto testable objects. Moreover we verify our method by using Jmeter tool [2] to measure the performance of Web, which indicate that broken components on a Web site has a bad effect in its performance.

Accurate web application performance testing relies on the use of loading tests based on a realistic client behaviour load model. Unfortunately developing such load models and associated test plans and scripts is tedious and error-prone with most existing web performance testing tools providing limited client load modelling capabilities. We describe a new approach and toolset that we have developed, MaramaMTE+, which improves the ability to model realistic web client load behaviour, automatically generates complex web application testing plans and scripts, and integrates load behaviour modelling with a generic performance engineering tool. MaramaMTE+ uses a stochastic form chart as its client loading model. A 3rd party web crawler application extracts structural information from a target web site, aggregating the collected data into a crawler database that is then used for form chart model generation. The performance engineer then augments this synthesized form chart with client loading probabilities. Realistic web loading tests for a 3rd party web load testing tool are then automatically generated from this resultant stochastic form chart client load model. We describe the development of our MaramaMTE+ environment, example usage of the tool, and compare and contrast the results obtained from our generated performance load tests against hand-built 3rd party tool load tests