Mutation testing is a technique in which faults (mutants) are injected into a program or application to assess its test suite effectiveness. It works by inserting mutants and running the application's test suite t...
详细信息
ISBN:
(纸本)9781450356992
Mutation testing is a technique in which faults (mutants) are injected into a program or application to assess its test suite effectiveness. It works by inserting mutants and running the application's test suite to identify if the mutants are detected ( killed) or not (survived) by the tests. Although computationally expensive, it has proven to be an effective method to assess application test suites. Several mutation testing frameworks and tools have been built for the various programing languages, however, very few tools have been built for the javascript language, more specifically, there is a lack of mutation testing tools for the *** runtime and npm based applications. The npm Registry is a public collection of modules of open-source code for ***, front-end web applications, mobile applications, robots, routers, and countless other needs of the javascript community. The over 700,000 packages hosted in npm are downloaded more than 5 billion times per week. More and more software is published in npm every day, representing a huge opportunity to share code and solutions, but also to share bugs and faulty software. In this paper, we briefly describe prior work for mutation operators in javascript and ***, and propose Mutode, an open source tool which leverages the npm package ecosystem to perform mutation testing for javascript and *** applications. We empirically evaluated Mutode effectiveness by running it on 12 of the top 20 npm modules that have automated test suites.
Using javascript as a description language can increase the productivity of application programs on embedded systems. Since javascript is a dynamic language, it is important for a javascript virtual machine (VM) to ef...
详细信息
ISBN:
(纸本)9781450351911
Using javascript as a description language can increase the productivity of application programs on embedded systems. Since javascript is a dynamic language, it is important for a javascript virtual machine (VM) to efficiently identify the types of first-class values and perform type-based dispatches while executing VM instructions. Even though the use of tagged pointers is a well-known technique for these operations, the VM implementer has to decide on suitable bit patterns in a tagged pointer according to the characteristics of the target program. This paper presents a novel framework that can generate a customized javascript VM on the basis of datatype specifications and operand specifications given by the programmer and instruction definitions supplied by the framework. Datatype specifications describe adequate internal representations of necessary datatypes for a target program and operand specifications do possible operand datatypes for all instructions, while instruction definitions describe the behaviors of all instructions. The generated VM is specialized in the sense that it has efficient and minimum type-based dispatching code for all instructions.
Developers often make mistakes while developing a software. Also,despite being a popular language, javascript codes are not free from errors. Though developers and testers give their best effort to minimize these bugs...
详细信息
ISBN:
(纸本)9781538651636
Developers often make mistakes while developing a software. Also,despite being a popular language, javascript codes are not free from errors. Though developers and testers give their best effort to minimize these bugs, often times the occurrence of bugs becomes inevitable. Very few works have been conducted to generate bug patterns in javascript source code. The existing works suggest that more bug patterns can be found out and also their verification techniques are not clear. To solve these issues, this paper suggests an approach of generating bug patterns from the syntactic structure of the source code. We have proposed six algorithms to generate six types of bug patterns from javascript source code. This work is also verified by commit log analysis of some big projects from GitHub. We found out 73 bug patterns by analyzing the commit log messages of 7 GitHub projects.
Data persistence refers to an characteristic that data needs to outlive its creator. In recent years, NVM (Non-volatile Memory), a new type of computer memory supporting memory like byte-addressable access and disk-li...
详细信息
ISBN:
(纸本)9781538673089
Data persistence refers to an characteristic that data needs to outlive its creator. In recent years, NVM (Non-volatile Memory), a new type of computer memory supporting memory like byte-addressable access and disk-like persistence, became a promising technique for facilitating data persistence in memory and its management. So far NVM has been supported in many programming languages such as C, C++, and Java. Meanwhile, it has not yet been well supported in javascript, a popular scripting language for software development. This paper presents JSNVM, an extension to javascript's runtime and execution engine, to support data persistence in javascript using NVM. JSNVM consists of (1) a javascript persistent object pool that serves as a persistent heap in which persistent objects are created and managed. This pool is also enhanced for guaranteeing data safety and consistency;and (2) a set of javascript persistent APIs that provide programmers with a support in creating, managing, and accessing persistent data in an easy-to-use and safe manner. We have implemented JSNVM and evaluated it against two database-supported data persistence styles (i.e., MongoDB's object store and indexedDB's binary store) on micro-benchmarks and real-world applications. The evaluation results show that compared with MongoDB's object store, JSNVM can achieve a 1.6x speedup;when applied to access binary data, JSNVM can achieve a 24.6x speedup over indexedDB's binary store, denoting that JSNVM can enhance performance of javascript applications in practice. JSNVM is planned to be publicly available by the end of 2018.
We present a framework for trustworthy symbolic execution of javascripts programs, whose aim is to assist developers in the testing of their code: the developer writes symbolic tests for which the framework provides c...
详细信息
ISBN:
(纸本)9781450364416
We present a framework for trustworthy symbolic execution of javascripts programs, whose aim is to assist developers in the testing of their code: the developer writes symbolic tests for which the framework provides concrete counter-models. We create the framework following a new, general methodology for designing compositional program analyses for dynamic languages. We prove that the underlying symbolic execution is sound and does not generate false positives. We establish additional trust by using the theory to precisely guide the implementation and by thorough testing. We apply our framework to whole-program symbolic testing of real-world javascript libraries and compositional debugging of separation logic specifications of javascript programs.
We present JSExplain, a reference interpreter for javascript that closely follows the specification and that produces execution traces. These traces may be interactively investigated in a browser, with an interface th...
详细信息
ISBN:
(纸本)9781450356404
We present JSExplain, a reference interpreter for javascript that closely follows the specification and that produces execution traces. These traces may be interactively investigated in a browser, with an interface that displays not only the code and the state of the interpreter, but also the code and the state of the interpreted program. Conditional breakpoints may be expressed with respect to both the interpreter and the interpreted program. In that respect, JSExplain is a double-debugger for the specification of javascript.
This paper describes one solution for execution of javascript code inside Java Enterprise Edition (Java EE) application servers. Since Java Virtual Machine (Java VM) is able to execute javascript code, it is possible ...
详细信息
ISBN:
(纸本)9781538649275
This paper describes one solution for execution of javascript code inside Java Enterprise Edition (Java EE) application servers. Since Java Virtual Machine (Java VM) is able to execute javascript code, it is possible to integrate javascript into Java EE. Instead of implementing javascript code in *** server, we have decided to integrate javascript inside Java EE environment. This way, it is possible to call other Java EE modules within javascript code, since it is now a part of the enterprise system. To achieve that goal, we have designed an architecture which introduces a Middleware as a link between Enterprise system and javascript code. We have also measured performance of three usual platforms for javascript execution and concluded that javascript inside Java VM is not significantly slower than the *** system.
The popularity and wide adoption of javascript both at the client and server side makes its code analysis more important than ever before. Most of the algorithms for vulnerability analysis, coding issue detection, or ...
详细信息
ISBN:
(纸本)9781538682906
The popularity and wide adoption of javascript both at the client and server side makes its code analysis more important than ever before. Most of the algorithms for vulnerability analysis, coding issue detection, or type inference rely on the call graph representation of the underlying program. Despite some obvious advantages of dynamic analysis, static algorithms should also be considered for call graph construction as they do not require extensive test beds for programs and their costly execution and tracing. In this paper, we systematically compare five widely adopted static algorithms - implemented by the npm call graph, IBM WALA, Google Closure Compiler, Approximate Call Graph, and Type Analyzer for javascript tools - for building javascript call graphs on 26 WebKit SunSpider benchmark programs and 6 real-world *** modules. We provide a performance analysis as well as a quantitative and qualitative evaluation of the results. We found that there was a relatively large intersection of the found call edges among the algorithms, which proved to be 100% precise. However, most of the tools found edges that were missed by all others. ACG had the highest precision followed immediately by TAJS, but ACG found significantly more call edges. As for the combination of tools, ACG and TAJS together covered 99% of the found true edges by all algorithms, while maintaining a precision as high as 98%. Only two of the tools were able to analyze up-to-date multi-file *** modules due to incomplete language features support. They agreed on almost 60% of the call edges, but each of them found valid edges that the other missed.
As a result of the large scale and diverse composition of modern compiled javascript applications, comprehending overall program structure for debugging is challenging. In this paper we present our solution: MetropolJ...
详细信息
ISBN:
(纸本)9781450357142
As a result of the large scale and diverse composition of modern compiled javascript applications, comprehending overall program structure for debugging is challenging. In this paper we present our solution: MetropolJS. By using a Treemap-based visualization it is possible to get a high level view within limited screen real estate. Previous approaches to Treemaps lacked the fine detail and interactive features to be useful as a debugging tool. This paper introduces an optimized approach for visualizing complex program structure that enables new debugging techniques where the execution of programs can be displayed in real time from a bird's-eye view. The approach facilitates highlighting and visualizing method calls and distinctive code patterns on top of code segments without a high overhead for navigation. Using this approach enables fast analysis of previously difficult-to-comprehend code bases.
暂无评论