Structured query language (SQL) related tools

The widespread adoption of web services as an instant means of information dissemination and various other transactions, including those having financial consequences, have essentially made them a key component of today\u27s Internet infrastructure. Underneath the infrastructure, relational database plays an important role, in a sense, as organizing data and making the retrieval and insertion of the data in an efficient and secure fashion. Structured Query Language (SQL) is designed to query data contained in a relational database. SQL is important as it is the only way for a user to interact with a relational database. But little focus has been put on SQL because people consider SQL as a simple language. But in fact, SQL legacy code repository could be as huge as some mainstream languages such as C, Java etc. In this paper, we focus on SQL Injection Attacks and SQL Code Coverage

Efficient branch and node testing

Software testing evaluates the correctness of a program’s implementation through a test suite. The quality of a test case or suite is assessed with a coverage metric indicating what percentage of a program’s structure was exercised (covered) during execution. Coverage of every execution path is impossible due to infeasible paths and loops that result in an exponential or infinite number of paths. Instead, metrics such as the number of statements (nodes) or control-flow branches covered are used. Node and branch coverage require instrumentation probes to be present during program runtime. Traditionally, probes were statically inserted during compilation. These static probes remain even after coverage is recorded, incurring unnecessary overhead, reducing the number of tests that can be run, or requiring large amounts of memory In this dissertation, I present three novel techniques for improving branch and node coverage performance for the Java runtime. First, Demand-driven Structural Testing (DDST) uses dynamic insertion and removal of probes so they can be removed after recording coverage, avoiding the unnecessary overhead of static instrumentation. DDST is built on a new framework for developing and researching coverage techniques, Jazz. DDST for node coverage averages 19.7% faster than statically-inserted instrumentation on an industry-standard benchmark suite, SPECjvm98. Due to DDST’s higher-cost probes, no single branch coverage technique performs best on all programs or methods. To address this, I developed Hybrid Structural Testing (HST). HST combines different test techniques, including static and DDST, into one run. HST uses a cost model for analysis, reducing the cost of branch coverage testing an average of 48% versus Static and 56% versus DDST on SPECjvm98. HST never chooses certain techniques due to expensive analysis. I developed a third technique, Test Plan Caching (TPC), that exploits the inherent repetition in testing over a suite. TPC saves analysis results to avoid recomputation. Combined with HST, TPC produces a mix of techniques that record coverage quickly and efficiently. My three techniques reduce the average cost of branch coverage by 51.6–90.8% over previous approaches on SPECjvm98, allowing twice as many test cases in a given time budget

Mitigating the Uncertainty and Imprecision of Log-Based Code Coverage Without Requiring Additional Logging Statements

Understanding code coverage is an important precursor to software maintenance activities (e.g., better testing). Although modern code coverage tools provide key insights, they typically rely on code instrumentation, resulting in significant performance overhead. An alternative approach to code instrumentation is to process an application’s source code and the associated log traces in tandem. This so-called “log-based code coverage” approach does not impose the same performance overhead as code instrumentation. Previous work has introduced LogCoCo — a tool that implements log-based code coverage for Java. While LogCoCo breaks important new ground, it has fundamental limitations, namely: uncertainty due to the lack of logging statements in conditional branches, and imprecision caused by dependency injection. In this thesis, we propose Log2Cov, a tool that generates log-based code coverage for programs written in Python and addresses uncertainty and imprecision issues. We evaluate Log2Cov on three large and active open-source systems. More specifically, we compare the performance of Log2Cov to that of Coverage.py, an instrumentation-based coverage tool for Python. Our results indicate that 1) Log2Cov achieves high precision without introducing runtime overhead; and 2) uncertainty and imprecision can be reduced by up to 11% by statically analyzing the program’s source code and execution logs, without requiring additional logging instrumentation from developers. While our enhancements make substantial improvements, we find that future work is needed to handle conditional statements and exception handling blocks to achieve parity with instrumentation-based approaches. We conclude the thesis by drawing attention to these promising directions for future work

Advanced extravehicular activity systems requirements definition study. Phase 2: Extravehicular activity at a lunar base

The focus is on Extravehicular Activity (EVA) systems requirements definition for an advanced space mission: remote-from-main base EVA on the Moon. The lunar environment, biomedical considerations, appropriate hardware design criteria, hardware and interface requirements, and key technical issues for advanced lunar EVA were examined. Six remote EVA scenarios (three nominal operations and three contingency situations) were developed in considerable detail

Automated Unit Testing of Evolving Software

As software programs evolve, developers need to ensure that new changes do not affect the originally intended functionality of the program. To increase their confidence, developers commonly write unit tests along with the program, and execute them after a change is made. However, manually writing these unit-tests is difficult and time-consuming, and as their number increases, so does the cost of executing and maintaining them. Automated test generation techniques have been proposed in the literature to assist developers in the endeavour of writing these tests. However, it remains an open question how well these tools can help with fault finding in practice, and maintaining these automatically generated tests may require extra effort compared to human written ones. This thesis evaluates the effectiveness of a number of existing automatic unit test generation techniques at detecting real faults, and explores how these techniques can be improved. In particular, we present a novel multi-objective search-based approach for generating tests that reveal changes across two versions of a program. We then investigate whether these tests can be used such that no maintenance effort is necessary. Our results show that overall, state-of-the-art test generation tools can indeed be effective at detecting real faults: collectively, the tools revealed more than half of the bugs we studied. We also show that our proposed alternative technique that is better suited to the problem of revealing changes, can detect more faults, and does so more frequently. However, we also find that for a majority of object-oriented programs, even a random search can achieve good results. Finally, we show that such change-revealing tests can be generated on demand in practice, without requiring them to be maintained over time

Evolutionary Approach to Efficient Provisioning and Self-organization in Wireless Sensor Networks (WSN)

Advances in low-power digital integration and microelectro-mechanical systems (MEMS) have paved the way for micro-sensors. These sensors are equipped with data processing capabilities along with sensory circuits. Sensor data are processed on these individual sensors and transmitted to the target (sink). Lowcost integration and small sizes of these sensors have generated special interest in the area of disposable-sensors and large scale platform management. Queries to these sensors are addressed to nodes which have data satisfying the same condition. However, these sensors may be constrained in energy, bandwidth, storage, and processing capabilities. Large number of such sensors along with these constraints creates a sensor-management problem. At the network layer it amounts to setting up the efficient route that transmits the non-redundant data from source to the sink in order to maximize one or more sensor objectives (e.g. battery (and sensor's) life, Sensor-Data yield). This is done while adapting to changing connectivity due to failure of some nodes and new nodes powering up. First part of the thesis propose a reduced-complexity genetic algorithm (GA) for optimization of multi-hop battery-constrained sensor networks. The goal of the system is to generate optimal number of sensor-clusters with cluster-heads. It results in minimization of the power consumption of the sensor system while maximizing the sensor objectives (coverage and exposure). The genetic algorithm is used to adaptively create various components such as cluster-members, cluster-heads, and next-cluster. These components are then used to evaluate the average fitness of the system based on the sequence of communication links towards the sink. We then enhance the genetic algorithm (GA) approach for secure deployment of resource constrained multi-hop sensor networks. The goal in this case is to achieve secure coverage and improve battery life by dynamically optimizing security attributes (Like authentication and encryption). Further, we augment the GA approach for intrusion detection of resource constrained multi-hop sensor networks. Traditional intrusion detection mechanisms have limited applicability to the sensor networks due to scarce battery and processing resources. Therefore, we propose an effective scheme that would offer a power efficient and lightweight approach to identify malicious attacks. We evaluate sensor node attributes by measuring the perceived threat and its suitability to host local monitoring node (LMN) that acts as trusted proxy agent for the sink and capable of securely monitoring its neighbors. Security attributes in conjunction with genetic algorithm jointly optimizes the selection of monitoring nodes (i.e., LMN) by dynamically evaluating node fitness by profiling workloads patterns, packet statistics, utilization data, battery status, and quality-of-service compliance. Second part of the thesis delves into application of Information Technology (and Industrial) Systems and devices where the use of sensor networks can deliver non-intrusive and effective telemetry for group-based server management. These systems (Like Data Centers or Shipment tracking) face major challenges in seamless integration of telemetry and control data that is essential to various autonomic management functions related to power, thermal, reliability, predictability, survivability, locality and adaptability. Such systems that are supported by a dense network of sense-points operating in noisy environment (Metals, Cables) are required to deliver reliable trends, measurements and analysis in a timely fashion. The traditional approaches to provide distributed observability and control using wired solutions are static, expensive, and nonscalable. We apply the proposed GA approach for this unique environment that replaces static wired sensors with dynamically reconfigurable battery-powered wireless sensors. The proposed technique employs machine learning approach to optimize sensor node function assignment, clustering decisions, route establishment and data collection trees for improved throughput that results in effective controls

Parallel, Cross-Platform Unit Testing for Real-Time Embedded Systems

Embedded systems are used in a wide variety of applications (e.g., automotive, agricultural, home security, industrial, medical, military, and aerospace) due to their small size, low-energy consumption, and the ability to control real-time peripheral devices precisely. These systems, however, are different from each other in many aspects: processors, memory size, develop applications/OS, hardware interfaces, and software loading methods. Unit testing is a fundamental part of software development and the lowest level of software testing, as it tests individual or groups of functions, methods, and classes, to increase confidence that the developed software satisfies both software specifications and user requirements. Although hundreds of unit testing frameworks exist, none of them address the diverse properties of real-time embedded platforms. This inspires us to introduce XEUnit, a cross-platform unit testing framework for real-time embedded systems. XEUnit provides scalability to the framework by supporting parallel execution on multiple embedded platforms simultaneously. To address the time constraints in real-time embedded systems, we evaluate the impact of runtime overhead from traditional instrumentation through a case study of time-sensitive algorithms. Then, we introduce iterative instrumentation, which is a code coverage technique without runtime overhead, along with a case study demonstrating the effectiveness of this technique. Although iterative instrumentation can measure code coverage effectively in time-sensitive applications, the total execution cost of this approach is much higher than traditional instrumentation due to the execution of multiple variants of the system under test. This leads to scalability and performance issues especially in large applications. To solve these issues, there are two approaches we use: reducing the number of variants and executing them simultaneously. To reduce the number of variants, we present cluster iterative instrumentation, a graph clustering technique that can reduce the number of nodes in a control flow graph resulting in lower execution time. We also provide a case study of node coverage of control software to show the efficiency of cluster iterative instrumentation compared to iterative instrumentation. In addition to reducing the number of variants, the other method is to execute multiple variants at the same time. Because all executions are independent from each other, we can use parallel execution on multiple embedded platforms. Thus, we design and implement a parallel unit testing framework for real-time embedded system along with a case study comparing the execution times from different numbers of embedded platforms (executing nodes). Our final contribution is a cross-platform unit testing framework using the concepts of runtime adapters and a runtime protocol that enables testers to run code across different embedded platforms. We also demonstrate the effectiveness of this framework by testing black-box test cases on seven different embedded platforms. Overall, our results indicate that cluster iterative instrumentation with parallel unit testing can address the scalability and performance issues, and the case studies demonstrate that XEUnit can effectively test the same code on a variety of embedded platforms