Fuzzy complexity assessment model for resource negotiation and allocation in agent-based software testing framework

https://doi.org/10.1016/j.eswa.2005.01.008Get rights and content

Abstract

Although each paradigm has its own influence in the software engineering field on the support of its proficiencies, due to the exceptional growth of the software industry, researchers continue to strive for more efficient and powerful techniques. As new requirements arise, on the one hand, from the increasing complexity of modern software systems, and on the other hand, from distribute of today's information economies, it has been recognized that the modularity and reusability provided by existing techniques and approaches are in sufficient. Agents are being advocated as a next generation ad hoc model for engineering complex, distributed systems they facilitate the automated software testing by virtue of their high-level decomposition, independency and parallel activation. Here, we address a set of more specific characteristics of agent-based approach (modularity, independency and parallel activation) and its efficacy in software testing. In this paper, we do not just described the claims for agent-based approach in software testing, also developed an ad hoc distributed multi-agent system for software. The multi-agent system illustrated here is on the basis of few basic operational real-world testing techniques, as an attempt to describe how to practice Agent-Oriented Software Testing (AOST), which has not previously done.

Introduction

Delivering high quality software for real-world applications is difficult. A wide range of software engineering paradigms have been recently devised (e.g. object-orientation (CianCarini and Wooldridge, 2001, Meyer, 1998), component ware (Szyperski, 1998), design patterns (Booch, 1994, Gamma et al., 1995) and software architectures (Booch, 1994, Pressman, 2001, Sommerville, 1998)) either to make the engineering process easier or to extend the complexity of applications that can feasibly be built (Jennings, 2000). As new requirements arise, on the one hand, from the increasing complexity of modern software systems, and on the other hand, from distribute of today's information economies, it has been recognized that the modularity and reusability provided by other techniques and approaches are in sufficient. Although each paradigm has its own contribution in the software engineering field on the support of their proficiencies, due to the exceptional growth of the software industry, researchers continue to strive for more efficient and powerful techniques (Jennings, 2000, Petrie, 2001, Wooldridge and Jennings, 1995).

Agents are being advocated as a next generation ad hoc model for engineering complex, distributed systems (Jennings, 2000, Jennings and Wooldridge, 2000, Petrie, 2001, Wooldridge and Jennings, 1995). Several approaches to agent-oriented software engineering have been developed, ranging from structured, informal methodologies, to formal ones (Booch, 1994). Agent-Oriented Software Engineering (AOSE) (CianCarini and Wooldridge, 2001, Dhavachelvan and Uma, accepted for publication, Jennings, 2000, Jennings and Wooldridge, 1998, Jennings and Wooldridge, 2000, Petrie, 2001) explanations lacking in details that would allow a software tester to decide easily how to shipping to agent-based software testing. Due to the above claim, there has been comparatively little work on agent-based testing as a serious software engineering paradigm that can significantly enhance development in wide range of applications. These shortcomings can be rectified by recasting the essential components of agent systems into more traditional software engineering concepts (Dhavachelvan and Uma, accepted for publication, Jennings, 2000). Here, we address a set of more specific characteristics of agent-based approach (modularity, independency and parallel activation) that supports the distributed nature of frameworks to be developed and its efficacy in software testing.

Effective test automation can be achieved by dividing the testing components to a maximum possible limit and maintaining by different units with higher degree of independency. Agent technologies facilitate the automated software testing by virtue of their high-level decomposition, independency and parallel activation (Franklin, 1996). In this paper, we do not just described the agent-based approach in software testing, also developed a multi-agent system for software testing with agent qualities. The multi-agent system illustrated here is on the basis of few basic operational real-world testing techniques (Basali & Selby, 1985), as an attempt to describe how to practice agent-based software testing, which has not previously done. The advantages of multi-agent systems are that they can compartmentalize specialized task knowledge, organize them to avoid processing bottlenecks, and can be built expressly to deal with dynamic changes in the agent environment (Castro-Schez, Castro, & Zurita, 2004).

Defining and classifying a relatively new phenomenon is always a difficult task to face the objections to basic definitions, arguments that important points have been overlooked, or claims that it is really nothing new anyway (Dhavachelvan and Uma, accepted for publication, Carolyn, 1999, Kitchenham et al., 2002, Avison et al., 1999, Jennings, 2000, Sjoberg et al., 2002). Bringing together agents and other fields of software engineering might be difficult, as the advantages of agent technology are still not widely recognized. The method discussed here is to offer a definition for encompassing to cover the software testing phenomena, based on agents, at the preliminary level, yet sufficiently tight that it can rule out complex systems that are clearly not agent-based. This paper, therefore, provides a timely summary and enhancement of agent theory in software testing, which motivates recent efforts in adapting concepts and methodologies for Agent-Oriented Software Testing (AOST) to complex systems.

This paper is structured as follows. Section 2 describes the Multi-Agent System (MAS) for software testing. In Section 3, Fuzzy Repertory Table approach is applied for request negotiation and resource allocation in our proposed framework. In Section 4, the proposed MAS is evaluated on the basis of software agent qualities. In Section 5, experimental results are discussed. Finally, in Section 6, conclusion and future perspectives are presented.

Section snippets

Background information needed

Let S be the MAS constructed for providing variety of testing environments and it can be defined as, S={D1, D2,…,Dz, a1, a2,…,ax}, where D is the distributor agent, a is the testing agent and x is the number of testing agents and also the number of testing techniques available in the system.

Let A be the set of agents needed for the product P and it can be defined as, A={Dp,a1,a2ay}, where y is the number of testing agents and also the number of testing techniques needed by the product P.

If

Complexity assessment

In the issue of ‘Complexity Assessment’ of the products which are to be tested, they can be represented by their complexity related attributes. Here we developed a complexity assessment scheme with 19 attributes that characterize the product and the system with respect to their complexity as in Table 1. This scheme extends the Fuzzy Repertory Table (FRT) approach (Castro-Schez et al., 2004) to assess the ‘absolute complexity’ and ‘relative complexity’ of the products. In software testing, the

Evaluation of multi-agent system

Based on the factors and activities enumerated above, the following software agent qualities of the proposed MAS can be stated for testing environment modeling using agents.

  • 1.

    Co-ordinativity. Agents must be able to coordinate with other agents to achieve a common purpose or simply the local goals. The distributor agent has to coordinate with all testing agents to share the load based on the required testing techniques and to prepare the Integrated Test Report (ITR). Also, the testing agents have

Experimentation and result analysis

The minimal version of the proposed framework is constructed and tested in a LAN set up in the concept proving stage (Booch, 1994). The test samples are implemented in C++ as experimental projects by two different teams. Team-1 consists of four students and headed by an academician and the team-2 consists of four students and headed by a software developer. For each version of the same project, the number of test cases is defined as affixed package for a particular testing technique. As said

Conclusion

The multi-agent system presented here is systematic and it does illustrate its effectiveness in selecting the appropriate assignment based on requirements. This methodology rests on the idea of building a conceptual model that is incrementally refined and it can be extended from other existing models of other fields of software engineering. The arguments and results support that the agent models fit better for testing the complex software systems. The concept described here allows specific

References (30)

  • N.R. Jennings

    On agent-based software engineering

    International Journal on Artificial Intelligence

    (2000)
  • D. Avison et al.

    Action research

    Communications of the ACM

    (1999)
  • Basali, R. V., & Selby, R. W. (1985). Comparing the effectiveness of software testing strategies. Technical report,...
  • G. Booch

    Object-oriented analysis and design with applications

    (1994)
  • B. Carolyn

    Seaman qualitative methods in empirical studies of software engineering

    IEEE Transactions on Software Engineering

    (1999)
  • J.J. Castro-Schez et al.

    Fuzzy repertory table: A method for acquiring knowledge about input variables to machine learning algorithm

    IEEE Transactions on Fuzzy Systems

    (2004)
  • Chavez, A., Mouka, A., & Maes, P. (1997). Challenger: A multi-agent system for distributed resource allocation....
  • Dhavachelvan, P., & Uma, G. V. (2005). Multi-agent based integrated framework for intra-class testing of...
  • Franklin, S., & Graesser, A. (1996). Is it an agent, or just a program?: A taxonomy for autonomous agent. Proceedings...
  • E. Gamma et al.

    Design patterns

    (1995)
  • S. Henry et al.

    Complexity measurement of a graphical programming language

    Software Practice and Experience

    (1988)
  • N.R. Jennings et al.

    Agent-oriented software engineering

  • B.A. Kitchenham et al.

    Preliminary guidelines for empirical research in software engineering

    IEEE Transactions on Software Engineering

    (2002)
  • Cited by (9)

    View all citing articles on Scopus
    View full text