International Journal of Emerging Trends & Technology in Computer Science (IJETTCS)

Web Site: www.ijettcs.org Email: editor@ijettcs.org, editorijettcs@gmail.com Volume 2, Issue 4, July August 2013 ISSN 2278-6856

Exalting Complexity Measures for Software Testing accompanying Multi Agents

Reema Ajmera1 , Dr. C.S. Lamba2
2 1 Research Scholar, NIMS University, Rajasthan Research Supervisor, , NIMS University, Rajasthan

Abstract: A wide range of metrics from the literatures are

being tested for their suitability in measuring changes in software complexity of software code at different levels of system partitioning. Reliability data from software tests and operational data of professional systems from the field are examined for their dependency on software complexity. It is obvious that more complex software requires more rigorous testing. Therefore current testing strategy is not adequate for testing requirement so we need a broader overview for complexity measure specially in the software testing. So with the help of this research work I tried to design a Complexity measure model with the help of Multi Agent System Environment that is MASST (multi agent based software testing). MASST model becomes very effective for software organization special in the phase of testing.

Keywords System testing technique (MASST), Multiagent Based System, Complexity measurement Technique, Reliability .

1. INTRODUCTION
There is the fundamental requirement for professional systems to provide high levels of availability. These systems consist usually of numerous hardware and software components. Software problems are one of the most important if not the dominant factor for system unavailability. Software crashes can lead to temporary system unavailability and workflow disruption. Operations can be resumed only after the software has recovered from the crash and the system is in normal state again. Complex systems usually consist of several software units each one being a potential cause of system unavailability due to such crashes. It is of primary concern of the software development and testing team to reduce the probability of such crashes by removing errors from the software code before product release. Testing strategies need to be designed in such a way to explore the error prone characteristics of the software. Software complexity metrics provide a quantified expression of the inherent characteristics of software. Testing strategies are being developed using this information to identify and focus on the more error-prone code. Effective debugging should provide software products that when released in the field, are free of error linked to these characteristics.[1] Delivering high quality software for real-world Volume 2, Issue 4 July August 2013

applications is difficult. A wide range of software engineering paradigms have been recently devised (e.g. object -orientation [2]. component ware, Design patterns [3, 4] and software architectures [4]) either to make the engineering process easier or to extend the complexity of applications that can feasibly be built [5]. Although each paradigm have their own influence 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 [2,6, 5]. Agents are being identified as a next generation model for engineering, complex, distributed systems [6,5,9]. Although there are an increasing number or deployed agent applications [7,8], there is no systematic analysis precisely what makes the paradigm effective [5]. When to use it and what type of applications makes use of it. Agent-Oriented Software Engineering (AOSE) [2, 6, 5,9,7] explanations lacking in details that would allow a software tester to decide easily when to shipping to agentbased software testing. Due to these claims, there has been comparatively little work on agent-based computing 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 component of agent systems into more traditional software engineering concepts [5,8].we do not just described the agent-based approach in software testing, also developed an evaluation framework (based on the attributes of complexity) for agent-oriented approach in software testing and its application to develop a multi-agent system for software testing. 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-based software testing, which has not previously done. There is a need to establish a software testing process that is cost effective and efficient to meet the market pressures of delivering low cost and quality software. Measurement is a key element of an effective and efficient software testing process as it evaluates the quality and effectiveness of the process. Moreover, it assesses the productivity of the personnel involved in testing activities and helps Page 56

International Journal of Emerging Trends & Technology in Computer Science (IJETTCS)

Web Site: www.ijettcs.org Email: editor@ijettcs.org, editorijettcs@gmail.com Volume 2, Issue 4, July August 2013 ISSN 2278-6856
improving the software testing procedures, methods, tools and activities [9]. is open and extensible. Lastly agents can be located in shared devices. PROPOSED FRAMEWORK We have identified the problem in software testing through various research literatures that is underline below: To reduce the probability of software crashes by removing errors from the software code before product release. To develop a multi-step evaluation process to measure complexity in reference of software testing. To identify Agents as a next generation model for engineering, complex, distributed systems Proposed agent oriented complexity measurement for software testing can be predictable as a next generation model for engineering complex, distributed system[10]. Although there are an increasing number of deployed agent applications, there is no systematic analysis precisely what makes the paradigm effective, when to use it and what type of applications make use of it. Due to these claims, there has been comparatively little work on agent-based computing as a serious software engineering paradigm that can significantly enhance development in wide area of applications. These shortcomings can be rectified by recasting the essential components of agent systems into more traditional software engineering concepts. In our system we integrate some of product metrics i.e. LOC, Cyclomatic complexity and Halsteads metric and place agents to evaluate this task. INTELLIGENT AGENTS The general definition of an intelligent agent is: Agents are sophisticated computer programs that act autonomously on behalf of their users, across open and distributed environments, to solve a growing number of complex problems. Intelligent agents possess certain key characteristics: They perform tasks on behalf of the user Can operate without direct user intervention [Morreale,98] GENERAL APPROACH AND METHODOLOGY The process has been broken down into five steps: 1. Accepts Codebase 2. Determining the types of jobs that will be done by agents 3. Send details to appropriate agent 4. Receive processed result from Agents 5. Implementing user interface, agent design 4.4.1.3 DESIGN PROCEDURE The procedures involved in the designing of agents are as follows. Here lists the various agents and their functionalities. List of agents and its description Module Name Description User Interface Agent: Accepts codebase from user a Sends it to Administrator agent and displays received calculated complexity from administrator agent. Page 57

2. RESULT AND ANALYSIS

In our previous section we presented various measurement testing techniques to measure complexity and after the study of various measurement techniques we find out there is a need of measurement technique which should be in terms of multi agent system for testing environment technique as experimental results show that the cost of development and testing of software are closely related to cost of development and testing of software which should result in terms of multi agent system technique. Product-oriented metrics (Line of code, Cyclomatic complexity and Halstead metric) , integrating the three procedure-oriented software complexity metrics i.e. LOC, Cyclomatic complexity and Halstead s metric measure the probability of error detection in system classes during testing and is to propose an investigation and analysis strategy to make these kinds of studies more reusable and comparable. Agent technologies enhance the complexity measure for software testing by virtue of their high level decomposition, independency and parallel activation. Now in this paper we develop a multi agent based complexity metric named as MASST which is closely related to reliability of software, the total software complexity is measured. These are required for accurate schedule and cost estimates, better quality products, and higher productivity. These help the developer in identifying source code that is error prone and difficult to test. Metrics also provide an insight into the software, as well as the processes used to develop and maintain it. Complexity measure plays a vital role in analysing and focusing System testing technique (MASST), Multi agent Based System, Complexity measurement Technique on particular phases of life cycle in respect of resource and effort. Testing complexity analysis can be used to allocate testing resources to those portions of the application that are most -likely to contain errors. Using this technique, all subsystems are analyzed to determine a numerical level of complexity. Then testing resources are allocated to each subsystem accordingly. Alternatively, levels of required test coverage could be determined based on the complexity analysis. For example, any subsystem above certain, predefined complexity was released than a subsystem of lesser complexity. Functionality-correctness, reliability, etc. and economy-cost effectiveness are major issues to measure. [Elammari,99] Here we do not just describe the agent based approach to measure complexity for software testing, also developed an evaluation framework. We propose a multi-agent system using agents to provide assistance during the complexity measurement. This system has several characteristics. Firstly, it minimizes the interference of the tester by automating the process of measure. Secondly, the measuring time is reduced while the fault detection ability increases. Thirdly, architecture suggested Volume 2, Issue 4 July August 2013

International Journal of Emerging Trends & Technology in Computer Science (IJETTCS)

Web Site: www.ijettcs.org Email: editor@ijettcs.org, editorijettcs@gmail.com Volume 2, Issue 4, July August 2013 ISSN 2278-6856
Administrator Agent: Create instance of module agents and distribute the code base to module agents. Token Agent: Split the code base into tokens and return these tokens to Administrator agent. Module Agents: Monitors the code base to measure, returns the specific complexity results to Administrator agent. WORKING OF MASST The MASST working model is depicted in figure 1. Figure shows how different agents are working together to perform given responsibilities. In our model our user is a tester who is measuring complexity of given source code module. User initiates interface agent by providing it codebase of which complexity should be measured. Interface agent passes on given source to Administrator agent to compile the given source. Administrator agent invokes token agent to split given source into tokens and returns to the administrator agent in the form of token. Further administrator agent invokes multi agents to calculate different complexities with specified goal and task specifications and tokens. Module agents measure complexity and send it to administrative agent. Interface agents display output for user. Every actor, roles are determined by master agent. It may be worth noting here that an actor may play multiple roles in the same or different contexts. For each actor and each role, enlist all the possible responsibilities, based on the role definition and activities associated with the actor. Actors, roles and responsibilities will help design the agent classes. For each identified activity, analyze the context (causes and consequences) to determine all interactions (if any). It may be worthwhile to note here that agent interactions may often fall into typical patterns of behavior that have been previously identified and used in other applications. So the process may begin by looking for these patterns. For each distinct interaction, determine the actors, exchange details, the typical pattern of behavior, the speech-acts used for the communication and the associated knowledge. This will help in designing the mental states of the agents and the ontology later. Master agent refines the analysis. For each agent and interaction, remove duplication and redundant information and thereafter it submits cumulated report to User Interface agent.[10] In given framework each agent performs their assigned activities and responsibilities. IMPLEMENTATION As we discussed in the above section how our MASST designed and work. In favour of sour research we develop a small application. In this section we specify how actually multi agent will be act to fulfill their responsibilities.

Figure 1 Proposed MASST System Architecture The idea behind agent-oriented thinking is to explore the applicability of the agent paradigm in given problem domain. In a very broad sense, it is about visualizing actors interacting with others in their environments for solving the given problem. An actor will act, based on its perceptions. It may also realize that it has insufficient knowledge and seek that supplementary information elsewhere to conduct an activity. Actors, activities and their coordination will lead to the conception of scenarios, which will get stitched together as the thinking process gradually evolves towards the goal. The key concepts in this thinking process are the actor, activity and scenario. We define MASST as the process that includes all activities (steps) for discovering, documenting and maintaining a set of specifications for actors (roles), activities (responsibilities) and interactions for the design of an agent based system. It may then primarily consist of the following steps: Master agent studies the scenario description and identify all the possible actors and main activities

Figure 2 Input interface User Interface agent: In our environment, interface Agent is designed to achieve the interaction between system and users. It realized the generality of user interface. After supplying codebase, the only thing we need to do is just to wait easily but need not know how or where test is performed. Agent will do everything for us. And the system will return the final result to users. One advantage of interface Agent is that it is a friendly interface. The main functions of interface Agent include: Describing users testing request in some kind of visual format;

Volume 2, Issue 4 July August 2013

Page 58

International Journal of Emerging Trends & Technology in Computer Science (IJETTCS)

Web Site: www.ijettcs.org Email: editor@ijettcs.org, editorijettcs@gmail.com Volume 2, Issue 4, July August 2013 ISSN 2278-6856
Communicating with other agents of the system, submitting the testing request and returning the resulting empathy to user; When user gives an incorrect request resulting empathy to user; Creating and administrating all the active Agent instances, including the status and life cycles of active Agents, Processing the communication of Agents. Processing the communication of Agents. Module Agents: As we define earlier that administrator agent create instances of module agents for each measurement technique. In our system administrator agent create three module agents these are: Line Agent: It receives codebase from administrator agent than it searches for comment lines using stack afterwards extracting these lines it returns total count of code lines. Cyclomatic Agent: It receives codebase from administrator agent than it searches for comment lines using stack afterwards extracting these lines it broke this in to tokens by comparing these tokens it calculates cyclomatic complexity and sends it to the administrator agent. Halstead Agent: It receives codebase from administrator agent than it searches for comment lines using stack afterwards extracting these lines it broke this in to tokens by comparing these tokens it calculates total occurrence of operators and operands and total occurrence of unique operator and unique operand then it calculates distinct complexities defined by Halstead sends it to the administrator agent. To develop this we use JAVA 5. Time estimation: Our system reduces also the test time by intellectually. We have tried to find out a way to implement the testing strategy using the concepts of agent oriented software engineering. We prepare an application for monitoring that instead of measuring complexity separately it can be measured on same platform with the help of agent oriented concept. In this we find that time taken by Multi agent based system is very less than when it is done by single agents.

Figure 3 Input to Measure When user gives an incorrect request description (such as file not found) interface Agent will display error information and prompt user to correct it. The main role of this agent is receiving, from the user, program information such as (Fig. 2,3): * Codebase Then send it to administrator agent. When it receives a message from the latter agent at the end of the testing process, it treats the message and shows the final reports about the results of the testing process such as (Fig. 4): * The total number of line of codes * The Cyclomatic complexity * The Halsteads measurements based on operators and operands

5 CONCLUSION AND FUTURE WORK

This paper has presented the results of several empirical studies performed. The studies combine literature study, collecting and analyzing quantitative data from data repositories and qualitative data from different sources, experiments, statistical hypotheses testing. A mixedmethod research design was applied to allow taking benefit of all available data, combining the results and answering questions that are not possible to answer otherwise. This work mainly analyzed available complexity measurement techniques in this thesis. Prior knowledge of the AOSE in the study, and combining MAS and different types of measurement techniques with one another and improve the validity of the results. In this paper we tried to resolve the issues related to following questions: How can software testing be performed efficiently and effectively?

Fig. 4 Measured Complexities Administrator Agent: Administrator Agent manages the whole system, processing the complex communication between the inside of the system, coordinating all the Agents in the system and distributes controls in the system. It is unique in the system. The main functions of administrator Agent include: The interface of the system with other systems or Agent systems;

Volume 2, Issue 4 July August 2013

Page 59

International Journal of Emerging Trends & Technology in Computer Science (IJETTCS)

Web Site: www.ijettcs.org Email: editor@ijettcs.org, editorijettcs@gmail.com Volume 2, Issue 4, July August 2013 ISSN 2278-6856
Describing different aspects of Complexity Measures i.e. we cant manage what we cant Measure The practice of complexity measurement during software development has been described. The complexity measurement family consists of two categories that are process and product. A complexity measure is developed to measure a particular attribute of software to make the task less complex for next level in respect to deliver quality product. The quality of metrics, the measurement program, and the processes for reporting defects, changes and effort were evaluated. These measurements are success factors to make software reliable and quality product. This work identified aspects with improvement potential for the complexity measure and proposed some improvements: a) Multi agent activities were proposed that could be added to the software process model, b) results in the form of multi agent framework for software testing. To reduce the probability of software crashes by removing errors from the software code before product release. It is identified that complexity measure helps in to achieve more predictability, lower the risk and reduce the software maintenance cost so it is required to achieve these goals we can move through measuring complexities before the product release. How can we curtail the tester snooping in the system testing life cycle? We have identified a framework of metrics in integration with the capability of multi agent systems combination of development approaches. With this the roll of tester will be played by Agent. To develop a multi-step evaluation process to measure complexity in reference of software testing. We tried to verifying existing theories and assessing existing methods in new contexts; i.e. the power of replication. This work identified emerging paradigm of agent oriented software engineering. We describe multi agent base framework to measure complexity. In it various agents are associated with software development life cycle to measure different complexities. To identify Agents as a next generation model for engineering, complex, distributed systems. Generating new theories, hypotheses or methods by analyzing data from new perspectives (as in grounded theory) or combining the results of several studies; i.e. the power of generalization: In our work we integrate different product complexity measures with multi agent system to reduce the probability of software crashes by removing errors from the software code before product release. The results of quantitative and qualitative studies have been combined in a model of the impact of development approaches on quality metrics. Development approaches Volume 2, Issue 4 July August 2013 should be studied in combination with one another, since approaches have multiple and crosscutting impacts on development practices and quality metrics. This work has identified a framework of metrics in integration with the capability of multi agent systems combination of development approaches. Metrics are defined in various parts of the literature. However, these metrics should be combined with one another. INTERPRETATION Our findings can contribute to both research community and software practitioner in many ways. To researchers who are interested in quality prediction, we confirm the important of complexity measures for software testing. To quality model builders, we suggest multi agent based metric framework that is potential predictors of fault proneness, maintainability and reliability. We also confirm that, regarding to the impact of design complexity on quality, correlation studies is too heterogeneous to generalize from them. In particular, there is no overall metric to measure complexity on fault proneness. Besides, the fault prediction model based on design metrics should be built differently for pre release defect fault and post release fault. To software practitioners who seek for early indicator of software quality, there are several suggestions. If the available software artifact is source code, practitioners should look for Line of Code (LOC), Cyclomatic Complexity and Halstead if they want to predict fault proneness. Besides, the metrics that is similar with these can be used in any software systems, without restrict to Object oriented software. To construct a measurement framework that can reflect the software quality, ones can take design metric list in Appendix A as a reference. FUTURE WORK This work covers multiple aspects of complexity measurement techniques applied in various phases of software development. Future work emanating from the research conducted in this thesis should include: In our work we prop up complexity metric with the help of multi agents. We have taken some of the product metrics in support of our work. Due to limited resources we cannot move for a broad range of complexity measures identified for different phases in the software development life cycle. In future, Agent activate automatically without user intervention as software needs to measure complexity: Presently in our system user initiates master agent to perform task in future it could be integrated with the development phases of software. According to this idea when each phase is accomplish agent activated in the environment to measure associated complexities. Agents can use KQML to communicate each other for knowledge sharing. MASST can be extended to generate test cases on the basis of measured cyclomatic complexity to branch coverage. MASST can be further used to run test scripts and maintain test logs. Page 60

International Journal of Emerging Trends & Technology in Computer Science (IJETTCS)

Web Site: www.ijettcs.org Email: editor@ijettcs.org, editorijettcs@gmail.com Volume 2, Issue 4, July August 2013 ISSN 2278-6856 References
[1] Software Complexity and Testing Effectiveness: An Empirical Study, Kostas Kevrekidis ,Stijn Albers ,Peter J. M. Sonnemans,Guillaume M. Stollman. [2] Agent-Oriented Software Engineering, P. CianCarini and M. Wooldridge (ed) (2001) vol.1957, L'lCS, Springer-Verlag. 2001. [3] Design PatIerns ,E. Gamma, R. Helm. R. Johnson, and J. Viis sides (1995), Addison-Wesley,1995. [4] Object-Oriented Analysis and Design with Applications, G. Booch (1994), AddisonWesley.1994. [5] On Agent-Based Software Engineering, Nicholas R. Jennings (2000), International Journal on Artificial Intelligence, 1 L 7 (2000). Elsevier, pp. 277-296. [6] Agent-Based Software Engineering, Charles Petrie (2001), Lecmre Notes in Artificial Intelligence, vol. 1957 . Springer-Verlag, 2001.pp.58-76. [7] Agent Technology: Foundations. Applications and Markers ,N.R. Jennings, M. Wooldridge (Eds) (998), Springer, Berlin. 1998. [8] Multiagent based Integrated Framework for Intraclasstesting of Object'Oriented Software, Dhavachelvan.P. and G.V.Uma (2004), Accepted for publication in International Journal on Applied Soft Computing, Elsevier. 2004 [9] Agent Oriented Software Engineering ,N.R. Jennings, M. Wooldridge(2000), J. Bradshaw (Ed). Handbook of Agent Technology, AAAIIMIT Press, 2000. [10] The Structural Complexity of Software: An Experimental Test, David P. Darcy, Chris F. Kemerer, Sandra A. Slaughter and James E. Tomayko. [11] MASST: Multi Agent Based Environment To Measure Complexity For Software Testing , Reema, Ajmera (2012,c) , Dr. C.S Lamba, World Academy of Informatics and Management Sciences, Vol1 Issue 2, April-May 2012, pp 58-64.

AUTHOR: Dr. C. S Lamba has Ph.D degree in Computer science and currently working as a Head of department, RIET Jaipur, India. He has more than 14 years of experience and holding diversified knowledge in the field of Information technology. He has published and Participated research paper / article in various conference/ seminar globally. Reema Ajmera received her M.Tech (C.S.)degree from Banasthali Vidhypeeph in 2007. She has some important books as a author as well as currently she is associating with the Jaipur National University at department of computer and systems sciences. Volume 2, Issue 4 July August 2013 Page 61