Abstract - Today, in Computerized and highly automated era, software process/products are vital aspects in our lives which therefore requires software systems to be highly reliable, usable, functional, efficient and of high quality. Hence testing of software systems from evolving phase and at every stage is imperative to attain above qualities. Softwaretesting aims at evaluating the capability of a program/system and to affirm the quality of software systems by systematically exercising the software in carefully controlled circumstances. Softwaretesting ensures quality assurance, reliability estimation, verification and validation. Softwaretesting executes program with actual test data which produces expected results with the intention of finding the errors. Testing illustrates differences between the expected behavior specified by the requirements and the observed behavior of the system. A good software test has a high probability of finding an as yet undiscovered error and a successful test discloses undiscovered error. This paper discuses about Softwaretesting and elaborates its objectives and testing techniques.
Model-Driven Testing or MDT is a new and promising approach for softwaretesting automation that can significantly reduce the efforts in the testing cycle of a software development. It consists in a black box test that uses structural and behavioral models to automate the tests generation process. In this paper, we describe a tool that allows developers to translate a software model written in UML with OCL formal constraints to its corresponding Java code, automating the generation of strong test-cases codes and specifying them not only in Java language but also in two formal languages, which are OCL and Alloy. This tool provides more reliable support by amalgamating different techniques, which strengthens the testing process.
Softwaretesting is more than just error detection. Testingsoftware is operating the software under controlled conditions, to verify, to detect errors, and to validate that what has been specified is what the user actually wanted. Verification is the checking or testing of items, including software, for conformance and consistency by evaluating the results against pre specified requirements. Error Detection, Testing should intentionally attempt to make things go wrong to determine if things happen when they shouldn’t or things don’t happen when they should. Validation looks at the system correctness-i.e. is the process of checking that what has been specified is what the user actually wanted. In other words, validation checks to see if we are building what the customer wants/needs, and verification checks to see if we are building that system correctly. Both verification and validation are necessary, but different components of any testing activity. The definition of testing according to the ANSI/IEEE 1059 standard is that testing is the process of analyzing a software item to detect the differences between existing and required conditions (that is defects/errors/bugs) and to evaluate the features of the software item.
Compared with traditional software products, the degree of current software products’ integration,modulization and complication is becoming higher and higher, which makes the testing of large-scale distributed software as a research hotspot. There are two reasons: the first is the development of Internet makes Web application system’s complexity and scale increasing. The traditional centralized softwaretesting methods have certain limitations, and the virtual testing environment and data is difficult to be realistic. The second is that global software development has become a trend, making software development is from centralized to the distributed method to realize software continuous integration and test anywhere and anytime. Aiming at the problems of softwaretesting, domestic and foreign scholars have put forward a series of test tools and frameworks. In accordance with the realization way,softwaretesting platform can be mainly divided into centralized testing and distributed test. Based on the basis of local testing, centralized softwaretesting framework usually is only for certain type or structure of softwaretesting, which is characterized as higher testing cost and lower efficiency. Li proposed a testing framework for model transformation, Stocks and Carrington put forward a testing framework based on specification introduction, Hartman proposed a model based testing tools AGEDIS, Marinov proposed a new automation testing in Java program test framework, realizing automatic generation of test cases and operation .
In this thesis it is proposed a distributed softwaretesting environment, that is able to test a wide variety of applications, such as a user space processes, kernel space processes, web applications and others. The testing environment is supported by an API of probes, where each probe has a specific test task according to its purpose. The base API can be extended to fulfil new testing requirements. This environment can be applied to general softwaretesting, programming contests and as a support for programming classes as the Mooshak automatic judging environment. The essential differences between both these environments is where the softwaretesting is performed. Unlike Mooshak, the proposed test environment can use client computers to do the actual test. This reduces the over- head on the server dramatically, which is especially useful when there are many test submissions simultaneously. These are the cases of classroom environments, lab environ- ments or programming contests. Another option is to have a set of testing computers, or slaves, ready to test user code. However this way more hardware is required. The only requirements for a computer to be a slave, part of the testing environment, is that is has installed a java client application that communicates with the master computer also addressed here as the main server. On the main server a portal allows users to access this testing environment. This master computer is also responsible to distribute the testing workload, according to the choosen strategy, sending to each slave the executable and testing probes, which includes the matching pairs of inputs and expected outputs. After the slaves had performed the tests, they generate a report with information on the tests, and send it back to the master, being available to the users on the portal. To support si- multaneous clients the portal is thread based, being launched a new thread to serve each new client connection. Communication between all computers in the test environment, is done using the BSD sockets API.
In this section difference between testing and debugging is shown. Softwaretesting is a process that can be systematically planned and specified. Test case design can be conducted, a strategy can be defined, and results can be evaluated against prescribed expectations. Debugging occurs as a consequence of successful testing. That is, when a test case uncovers an error, debugging is the process that results in the removal of the error. The purpose of debugging is to locate and fix the offending code responsible for a symptom violating a known specification. Debugging typically happens during three activities in software development, and the level of granularity of the analysis required for locating the defect differs in these three. The first is during the coding process, when the programmer translates the design into an executable code. During this process the errors made by the programmer in writing the code can lead to defects that need to be quickly detected and fixed before the code goes to the next stages of development
On method for effective testing is the identification of critical rout in the program. Standardized test of software is somehow impossible because the production and control of critical routs is difficult for software with average size. For creating control in the routs Finit Automate Machines (FAM) are used, in order to design a series of grammer and then the language for each rout by making use of FAM. Grammers create a chain sequences which should be followed through the program. These produced sequences decrease the complexity of identification of errors for effective testing in the process of examination purposefully. Keywords: Finit Automato Mach, Grammer, Path, SoftwareTesting.
Abstract—On time and within budget software project devel- opment represents a challenge for software project managers. Software management activities include but are not limited to: estimation of project cost, development of schedules and budgets, meeting user requirements and complying with stan- dards. Recruiting development team members is a sophisticated problem for a software project manager. Since the utmost cost in software development effort is manpower, software project effort and is associated cost estimation models are used in estimating the effort required to complete a project. This effort estimate can then be converted into dollars based on the proper labor rates. An initial development team needs to be selected not only at the beginning of the project but also during the development process. It is important to allocate the necessary team to a project and efficiently distribute their effort during the development life cycle. In this paper, we provide our initial idea of developing a prediction model for defining the estimated required number of test workers of a software project during the softwaretesting process. The developed models utilize the test instance and the number of observed faults as input to the proposed models. Artificial Neural Networks (ANNs) successfully build the dynamic relationships between the inputs and output and produce and accurate predication estimates.
muchos probadores. No se trata sólo de ser lo suficientemente bueno como para comprender las pruebas y tener un certificado ISTQB. Ya no trabajará sólo al interior del equipo de pruebas, necesitará integrarse más estrechamente con los representantes de las empresas y con los desarrolladores para ayudarse cuando sea necesario y para tratar de construir un producto de calidad en conjunto. Se espera que los probadores tengan conocimiento del dominio, habilidades de ingeniería de requisitos, que desarrollen habilidades de scripting y que posean fuertes habilidades para la comunicación, la lectura, la escritura y la negociación. b) Dado que los productos software cada vez son más complejos y a que están integrados en un ambiente casi libre, muchas de las llamadas pruebas no-funcionales se convertirán en grandes desafíos. Al mismo tiempo, el negocio, los usuarios y los clientes no querrán renunciar a la calidad. Para poder probar aspectos no funcionales, como la seguridad, la interoperabilidad, el rendimiento y la fiabilidad, se necesitarán probadores altamente especializados. Estos especialistas serán profesionales de pruebas de tiempo completo con un profundo conocimiento y con habilidades en el área de estas pruebas.
4) Devices Multitude Testing: This kind of testing creates the biggest testing challenge. Different mobile phones provide different features, hardware components, and different O.S. This creates a challenge of cost and time consuming when using “test on many devices” approach and need to be replaced by (cost) effective automated techniques [2, 3, and 7]. We can choose one of three options to handle the device challenge: either to testing exclusively using real devices, testing exclusively using emulated devices, or using a combination of both. Using real devices will explore all the limitations in the real hardware and the firmware combination, but it can be costly and time consuming. While in other hand it is easier to manage emulated devices through the ability to load different devices updatable profiles on one platform and exchange among them in a simple and direct way which is cost effective solution, however emulators lack the limitations, and quirks, and characteristics provided by the real devices and does not cover the exact behavior for external conditions like crowding and noisy environment, also emulation depends in PC power. Another suggested solution is to release (free of cost) prototype version of the application to be tested, running it on a multitude of devices, and collect, store, and analyze run-time data and failures [1, and 8].Testing by using a combination of both emulation and real device create the opportunity to gain advantages of both approach. An emulated environment enhances the speed and device diversity at a relatively low cost. The real devices verify the applications functionality and ensure that all development objectives have been met.
The Agent register table includes all information that identifies the Agent, besides its ID, address, name, etc. It is an important part that records the specific method and the service function of the cooperation of Agents. According to this register table, administrator Agent creates Agent instances and uses them to create an instance, it is necessary to analyze the testing request, then try to find out what type of Agent need to be created and how to create it by accessing the register information of the administrator Agent. Finally, create it.
Los conceptos y expresiones matemáticas requieren por lo general un tiempo para que los estudiantes las digieran, por lo que la formación en ellas debe hacerse al ritmo de ellos y con muchos ejemplos y problemas aplicativos. Sin embargo, un curso es como un proyecto software: tiene limitaciones de tiempo. Es por esto que los profesores se enfrentan a un dilema: quieren cubrir contenidos que son de suma importancia para el estudio de los métodos formales, pero no tienen el tiempo suficiente para lograrlo. Para hacer frente a este problema, la experiencia sugiere que los cursos no deben ser demasiado ambiciosos, sino que se deben diseñar de forma focalizada. Por ejemplo, distribuir la formación en especificación formal, refinamiento y verificación formal en tres cursos diferentes; de esta forma el profesor se podría enfocar en cada uno de ellos en las partes fundamentales, y darles a los estudiantes el tiempo suficiente para que puedan aplicar las técnicas aprendidas. Después de terminar cada curso, pedirles estructurar y ejecutar un pequeño proyecto en el que requieran aplicar todo el conocimiento aprendido en el aula. De esta forma se les ofrece mayores oportunidades para aprender cómo aplicar los conceptos teóricos de manera efectiva en la práctica.
llegan a un acuerdo de que la primera hipótesis era incorrecta y que el software tiene defectos que necesitan ser determinados. Esto puede implicar que se entregue el software y esperar a que otros tengan que rendir cuentas. Aunque se puedan producir estas consecuencias, las personas tienen que enfrentar la realidad y corregir los problemas en lugar de centrarse en sus propias agendas. Tal vez este aspecto de la prueba está más estrechamente alineado con la ciencia que se practica actualmente . Si la investigación confirma la hipótesis, se hace amplia difusión del suceso, pero si la investigación confirma la hipótesis contraria, especialmente una que resulta ser políticamente incorrecta, los resultados pueden no ser publicados.
Computer systems are present in practically all of the main processes of modern so- ciety. This high dependency means that failures in such systems have a direct impact upon people lives. Computer system failures are mainly caused by software defects. The software reliability engineering (SRE) is the Ąeld that studies how to make software more reliable. SRE is a multi-discipline Ąeld, which integrates in essence, probability, statistics, and computer science. The research areas in SRE are varied, so, diversity questions could be raised as to: Which Ąelds of SRE have been most recently investigated? Which are the international SRE groups most active? Which problems are covered by the most cited SRE studies? Which are the emerging topics in SRE? Therefore, this study presents the results from a systematic mapping study on software reliability. This study considered the last 12 years of publications covering 92 publication venues (journals and internati- onal conferences), with a total sampling of 300 papers. Statistical techniques were used for clustering papers in terms of similarity, as well as for identifying the research topics of software reliability. The results showed that studies which adopt a purely theoreti- cal approach were predominantly greater in number than empirical studies. However, we observe that over the last few years the theoretical-empirical approach has become more relevant. Besides this, it was also observed that the factor Şexternal collaborationŤ presented itself as one of the most evident in those research centers of greater influence. Finally, among the research topics covered in this study, we identiĄed a trend through the results, towards a demand in theoretical-empirical research in softwaretesting for the coming years.
Depending on the nature of the model used, softwaretesting is called functional testing (also called specification-based testing) or structural testing (also called implementation-based testing). Models used in functional testing are based on software functional requirements while in structural testing are based on the software’s internal structure. Nowadays, the most part of softwaretesting is done using functional testing techniques, since they are less costly. However, as research works have been focused on structural testing, software industries do not have many formal ways to perform and assess the test of their products and end up using just heuristics to carry out their softwaretesting . A functional testing technique that has been commonly used in the software industry is Model Based Testing (MBT). The modeling technique most used to create such models is the Finite State Machines (FSMs). Besides software modeling, the FSMs are used as a basis to define functional testing criteria to be applied in test case selection and adequacy analysis. The FSMs are considered an excellent tool for software modeling, user/developer communication and testing, since their application is simple and intuitive. Although traditional
-------------------------------------------------------------------ABSTRACT-------------------------------------------------------------- This paper discusses genetic algorithms that can automatically generate test cases to test selected path. This algorithm takes a selected path as a target and executes sequences of operators iteratively for test cases to evolve. The evolved test case can lead the program execution to achieve the target path. An automatic path-oriented test data generation is not only a crucial problem but also a hot issue in the research area of softwaretesting today.
This paper presents the rationale and introduces the methodology for generating and optimizing test sets with basis on metrics derived from the dynamic analysis of the test object’s Java bytecode. A Control-Flow Graph is used as the underlying model for program representation, and it is build solely with basis on the high-level information extracted from the Java bytecode of the test object. Bytecode instructions are grouped into a smaller set of Basic Instruction and Call blocks with the intention of easing the representation of the test object’s control flow, and additional virtual nodes are defined to facilitate the dynamic analysis phase. The methodology for evaluating the test set includes instrumenting the bytecode for basic block analysis and structural event dispatch, and executing the instrumented test object using the generated test cases as inputs, with the intention of collecting trace files with which to derive coverage metrics. Methodologies for defining fitness functions in order to achieve the particular criteria- related test goals are introduced. A general overview on how our automated softwaretesting tool is integrated is given.
H i g h - l e v e l playing a key role as a mechanism for implementing program- language virtual machines (HLL VMs) have been ming languages. Languages that run on these execution environments have many advantages over languages that are compiled to native code. These advantages have led HLL VMs to gain broad acceptance in both academy and industry. However, much of the research in this area has been devoted to boosting the performance of these execution environments. Few efforts have attempted to introduce features that automate or facilitate some software engineering activities, including softwaretesting. This research argues that HLL VMs provide a rea- sonable basis for building an integrated softwaretesting environment. To this end, two softwaretesting features that build on the charac- teristics of a Java virtual machine (JVM) were devised. The purpose of the first feature is to automate weak mutation. Augmented with mutation support, the chosen JVM achieved speedups of as much as 95% in comparison to a strong mutation tool. To support the testing of concurrent programs, the second feature is concerned with enabling the deterministic re-execution of Java programs and exploration of new scheduling sequences.
Software systems are a big part of our lives and, more than ever, they require a high level of reliability. There are many software Verification and Validation (V&V) techniques that are concerned with quality control, security, robustness, and reliability; the most widely known are SoftwareTesting and Formal Methods. Formal methods and testing are techniques that can complement each other. While formal methods provide sound mechanisms to reason about the system at a more abstract level, testing techniques are still necessary for a more in-depth validation of the system and are often required by certification standards. Taking this into consideration, BETA provides a tool-supported, model-based testing approach for the B Method that is capable of generating unit tests from abstract B machines. In this the- sis, we present improvements made in the BETA approach and tool, and new cases studies used to evaluate them. Among these improvements, we integrated logical coverage criteria into the approach, reviewed the input space criteria that was already supported, and en- hanced the final steps of the test generation process. The approach now has support for automatic generation of oracle data and test case preambles, it has a feature for test data concretization, and a module that automatically generates executable test scripts. Another objective of this thesis was to perform more complex case studies using BETA and assess the quality of the test cases it produces. These case studies were the first to evaluate the test generation process as a whole, from test case design to implementation and execution. In our last experiments, we assessed the quality of the test cases generated by BETA, consid- ering each coverage criteria it supports, using code coverage metrics such as statement and branch coverage. We also used mutation testing to evaluate the ability of the generated test cases to identify faults in the model’s implementation. The results obtained were promis- ing, showing that BETA is capable of detecting faults introduced by a programmer or code generation tool and that it can achieve good coverage results for a system’s implementation based on a B model.
O usuário deve ativar o botão Enviar Bytes no computador transmissor e o software envia automaticamente 1000 pacotes de dados pela interface serial, via rádio. Cada pacote tem 38 bytes de informações. Optou-se por enviar pacotes de dados, pois os instrumentos de medição existentes no mercado operam usualmente enviando pacotes de informações, portanto, este software opera no mesmo padrão desses equipamentos comerciais de medições físicas. O tamanho do pacote foi definido de forma que os 38 bytes seriam suficientes para compor uma informação com data e hora da medição e com alguns valores numéricos relativos a medição de valores de grandezas físicas, como temperatura, umidade, etc. Cada byte do pacote corresponde ao caractere “ ª ” que é representado pelo número 170 da Tabela ASCII, escolheu-se este número, pois sua representação binária é 10101010, ou seja, é um valor intercalado de 1 e 0.