We propose a novel automated approach using deep learning techniques to classify assessment questions based on their cognitive complexity. To this end, we first heuristically annotated a dataset of ∼111.6K questions based on Revised Bloom's Taxonomy. Subsequently, we used transfer learning to train an attention-based model for question classification. Our experimental results indicate that our proposed approach outperforms existing classification techniques in terms of F1-Score. Moreover, our proposed model could correctly classify 74.04% of real-life questions.

We propose a set of four novel fault-based regression test case prioritization (TCP) techniques for object-oriented programs. We seed bugs into a program to create large number of mutants. We execute each mutant with the originally designed test suite. From this, we record the number of mutants for which a test case fails. Based on this, we prioritize the test cases using four base fault-based prioritization techniques that we have proposed. Finally, we combine the results of our four base prioritizers using three ensemble methods. We have conducted experimental studies to determine the effectiveness of our proposed approaches. Our experimental results show that our proposed TCP techniques exhibit superior performance over related techniques.

Fault localization techniques aim to localize faulty statements using the information gathered from both passed and failed test cases. We present a mutation-based fault localization technique called MuSim. MuSim identifies the faulty statement based on its computed proximity to different mutants. We study the performance of MuSim by using four different similarity metrics. To satisfactorily measure the effectiveness of our proposed approach, we present a new evaluation metric called Mut_Score. Based on this metric, on an average, MuSim is 33.21% more effective than existing fault localization techniques such as DStar, Tarantula, Crosstab, Ochiai.

In this article, we propose a hierarchical fault localization technique using a deep neural network (DNN). First, we prioritize the functions of a program based on their suspiciousness score. Subsequently, the fault is localized to specific statements within the top k suspected functions, where the value of k is determined heuristically. We use two function-level features to train a DNN for fault localization at the function level. Subsequently, the invocation information of the statements of the top-k functions is used to train another neural network to localize the faulty statement. We also report an extension to our approach for localizing multiple faults. This involves partitioning the failed test cases into clusters such that they target different faults. Our empirical evaluation indicates that our proposed approach requires examining 30.05 to 50.74% less code on an average, as compared to related fault localization techniques.

Fault localization (FL) is a time consuming and tedious task during program debugging. Most of the existing FL methods use statement coverage information to prioritize the statements based upon a computed suspiciousness score. We use predicate level execution trace to train a multilayer perceptron neural network model for effective fault localization. After prioritizing the fault at predicate level, we search the statements bounded by the predicates. Also, dynamic slicing is used to reduce the search space. We have experimentally studied the performance of our approach over Siemens suite and Space program and found that it is performing on an average 39.12% more effectively than DStar, a state-of-the-art bug localization technique.

Emotions can not be estimated with text alone as irony, humour, cadence etc. are important components of a speech. So, text has a limited capacity in conveying emotions. There are various work in sentiment analysis with text and speech but this project deals with the identification of mood in a non-discrete way. The traditional method of prediction emotion where labeling a certain number of discrete emotions is obviously a method of classification using various learning techniques. But can there be other techniques of describing and understanding emotions in speech? This paper first discusses the different dimensions of emotions and compares them with previous similar work (Chung and Yoon(2012)) [6], they classified the user's data into classes of 2 types (high, normal, low) and (high and low) with 3 and 2 classes respectively for both Valence and Arousal. Their performance was 53.4% and 51.0% for three classes and 66.6% and 66.4% accuracy for 2 classes on Valence and Arousal upon exact emotion prediction on DEAP dataset. Using the same dataset “Using Deep and Convolutional Neural Networks for Accurate Emotion Classification on DEAP Dataset” [5] concludes a CNN model providing 66.79% and 57.58% for exact Valence and Arousal prediction. The valence and arousal model follow accurate prediction on 2 or 3 classes, but we had a different approach of predicting emotions by placing a particular emotion in its respective quadrant in 2D valence and arousal axis. However, we had around 50-55% accuracy for the discrete model and our approach on quadrant prediction resulted in 76.2% accuracy using two different CNN architectures on RAVDESS dataset.

An unduly large number of test cases are required for effective testing of programmes containing complex decision statements. In this context, modified condition/decision coverage (MC/DC) testing has been acknowledged to provide effective testing using a test suite whose size is linear in the number of the clauses present in a predicate. MC/DC testing is well‐accepted and is mandated by several testing standards. T‐way testing is another prominent testing technique that helps to limit the combinatorial explosion of black‐box test cases. Its application to white‐box testing promises to provide effective testing with a comparatively small number of test cases. The authors empirically investigate the effectiveness of MC/DC testing vis‐à‐vis white‐box pairwise, 3‐way and 4‐way testing.

Distributed concolic testing (DCT) for complex programs takes a remarkable computational time. Also, the achieved modified condition/decision coverage (MC/DC) for such programs is often inadequate. We propose an improved DCT approach that reduces the computational time and simultaneously enhanced the MC/DC. We have named our approach SMCDCT (scalable MC/DC percentage calculator using DCT). Our experimental study on forty-five C programs indicates 6.62% of average increase in MC/DC coverage. Copyright © 2016 John Wiley & Sons, Ltd.

State models are widely used as specification or design artifacts and form the basis of various analysis techniques. In this paper, we make use of the advances in the area of random test generation to propose a novel approach to infer state models of black-box components from their executions. We also present an implementation and the results of applying our approach on a number of examples.

The current approaches for regression test selection of embedded programs are usually based on data- and control-dependency analyses, often augmented with human reasoning. Existing techniques do not take into account additional execution dependencies which may exist among code elements in such programs due to features such as tasks, task deadlines, task precedences, and intertask communications. In this context, we propose a model-based regression test selection technique for such programs. Our technique first constructs a graph model of the program; the proposed graph model has been designed to capture several characteristics of embedded programs, such as task precedence order, priority, intertask communication, timers, exceptions and interrupt handlers, which we consider important for regression-test selection. Our regression test selection technique selects test cases based on an analysis of the constructed graph model. We have implemented our technique to realize a prototype tool. The experimental results obtained using this tool show that, on average, our approach selects about 28.33% more regression test cases than those selected by a traditional approach. We observed that, on average, 36.36% of the fault-revealing test cases were overlooked by the existing regression test selection technique.

Abstract We propose a novel test coverage analysis technique for object‐oriented (OO) programs. An important novelty of our technique is the use of a single coherent model,Call‐based Object‐Oriented System Dependence Graph(COSDG), which helps in presenting a unified test coverage analysis framework for OO programs. COSDG represents both procedural and OO features. Our technique not only uses the model to identify the different program features that are to be exercised by a test suite, but also captures the executed program features in the model for subsequent coverage evaluation and reporting. During test executions, the model elements corresponding to the executed features are marked. This helps in determining coverageon‐the‐fly, without the need to store the execution traces in a file. We describe the computation of various coverage measures, both procedural and OO, from the model elements. We have implemented our model‐based technique in a prototype tool, named KANZ. The experimental results obtained by using the tool demonstrate the efficacy and efficiency of our technique in determining OO coverage measures. Copyright © 2010 John Wiley & Sons, Ltd.

This paper proposes a technique for dynamic slicing of UML architectural models. The presence of related information in diverse model parts (or fragments) makes dynamic slicing of Unified Modeling Language (UML) models a complex problem. We first extract all relevant information from a UML model specifying a software architecture into an intermediate representation, which we call a Model Dependency Graph (MDG). For a given slicing criterion, our slicing algorithm traverses the constructed MDG to identify the relevant model parts that are directly or indirectly affected during the execution of a specified scenario. One novelty of our approach is computation of dynamic slice based on the structural and behavioral (interactions only) UML models as against independently processing separate UML models, and determining the implicit interdependencies among different model elements distributed across model views. We also briefly discuss a prototype tool named Archlice, which we have developed to implement our algorithm.

Abstract This paper presents an approach to generate test cases from UML 2.0 sequence diagrams and subsequently prioritize those test cases using model information encapsulated in the sequence diagrams. The test cases generated according to the proposed approach satisfy the scenario coverage criterion and are suitable for system‐level testing. For prioritizing test cases, three different prioritization metrics are proposed. The values of these prioritization metrics can be analytically computed from the model information only. This paper also presents an approach to generate test data using a concept called rule‐based matrix. The prioritization metrics are used to control the number of test data without compromising the test adequacy. The effectiveness of the proposed approach has been verified using two industrial designs. Copyright © 2009 John Wiley & Sons, Ltd.

Coverage of system states during system testing is a nontrivial problem. It is because the number of system states is usually very large, and system developers often do not construct system state model. In this paper, we propose a method to design system test cases to achieve coverage of system states based on UML models constructed during normal development process. We use UML use case, sequence and class level statechart models to generate a set of sequences of scenarios that can achieve adequate coverage of system states.

This paper proposes a novel dynamic slicing technique for object oriented concurrent programs. We introduce the notion of object oriented concurrent program dependence graph (OOCPDG). Our dynamic slicing technique uses OOCPDG as the intermediate representation and is based on marking and unmarking the dependence edges as and when the dependences arise and cease at runtime. Our approach eliminates the use of trace files and is more efficient than existing algorithms. Besides, it encompasses different aspects of object oriented programming paradigm viz. inheritance, polymorphism from the slicing arena. It can handle dynamically created object based processes. It can also handle process interactions through shared memory and message passing. The updating to the intermediate representation is truly concurrent. Multiple processors execute different object based processes concurrently and require special handling. We also report a dynamic slicing tool called CDSOOCP (concurrent dynamic sheer for object oriented concurrent programs) which implements our dynamic slicing technique.

In early developmental stages of software, failure data is not available to determine the reliability of software, but design assessment is a must in this stage. We propose a model based on reliability block diagram (RBD) for representing real-world problems and an algorithm for analysis of these models in early phase of software development. We have named this technique early reliability analysis technique (ERAT). We have performed several simulations on randomly generated software models to compute reliabilities and coupling parameters. The simulation result shows that reliabilities are good quality indicator and coupling can be correlated with system reliability and can be used for system design assessment.

We present a novel method to automatically generate test cases based on UML state chart specifications. In our approach, we transform the conditional predicates on state transitions and apply function minimization technique to generate the test data. We use boundary value testing methods to generate effective test cases that satisfy test coverage criteria like full predicate coverage criteria and transition path coverage criteria. Our approach achieves adequate test coverage without unduly increasing the number of test cases. The test cases are generated for class as well as cluster level testing.

We propose a new dynamic slicing technique for object-oriented programs that is more efficient than the related algorithms. We use an extended system dependence graph (ESDG) as the intermediate program representation. Our dynamic slicing algorithm is based on marking and unmarking the edges in the ESDG as and when dependencies arise and cease during runtime.

Abstract Slicing of concurrent programs is a compute‐intensive task. To speed up the slicing process, we have developed a parallel algorithm. For this purpose we used the concurrent control flow graph (CCFG) as the intermediate representation. We used a network of communicating processes to develop our parallel algorithm. We have implemented our parallel algorithm and the experimental results appear promising. Copyright © 2004 John Wiley & Sons, Ltd.

We present a method for computing static slices of concurrent programs in a Unix process environment. As a part of our methodology, we introduce the notion of a Concurrent Program Dependence Graph (CPDG). A CPDG represents various aspects of concurrent programs in a hierarchical fashion. This hierarchical representation lets us compute static slices of programs at different levels of abstraction. Based on our methodology, we have implemented a static slicing tool supporting an option to view slices of programs at different levels of details. Experience with our implementation shows that this approach helps the user get a better understanding of the behavior of concurrent programs. Copyright © 2000 John Wiley & Sons, Ltd.

Active database management systems (ADBMSs) use event-condition-action (ECA) rules. Each ECA rule specifies what action is to be taken when an event occurs and the specified condition is satisfied. In this paper, we introduce a concurrency control scheme for handling nested cooperative transactions using detached-mode ECA rules of an ADBMS. A state transition model has been proposed to specify different kinds of nested cooperative transactions using detached-mode ECA rules. The correctness criterion for concurrent execution of such nested cooperative transactions has been stated formally. The problem of verification of the correct schedules and a concurrency control mechanism have also been dealt with.

Inspite of numerous research advancements made in recent years in the area of formal techniques, specification of real-time systems is still proving to be a very challenging and difficult problem. In this context, this paper critically examines state-of-the-art specification techniques for real-time systems and analyzes the emerging trends.