Search

Testing is the fundamental activity intentional at detecting and solving technical issues in the software source code. In software development, test suite plays a major role. A test suite is a collection of test case which describes actual input, action and an expected response to verify whether a system under test satisfies requirements correctly or not. A huge number of test cases are required for testing the software. The test cases may be redundant. So, the execution of all these test cases entails lot of effort, time and cost. So, it is necessary to make enhancement in the test suite that outcome in good coverage with less effort, time and cost. This work proposes a hybrid technique for test suite enhancement using data mining techniques. The hybrid approach is performed in three ways i) Classification based Clustering ii) Classification based Association iii) Classification based RTM approach used to make enhancement in the test suite and to improve accuracy.

Combinatorial Testing (CT) is an effective testing technique for detecting failures which are triggered by the interactions of various factors that influence the behaviour of a system. Although many studies in CT have designed elaborate test suites (called covering arrays) to systemically check each possible factor interaction, they provide weak support to locate the concrete failure-inducing interactions, i.e., the Minimal Failure-causing Schemas (MFS).To this end, a variety of MFS identification approaches have been proposed. However, as this study reveals, these approaches suffer from various issues such as cannot identify multiple overlapping MFSs, cannot handle MFSs with high degrees, cannot be applied to systems with large number of parameters, etc. These issues are essentially caused by the exponential computing complexity of checking every interaction in the test cases. Therefore, they can only focus on a subset of all the possible interactions, and thereby resulting in many interactions unnoticed. Ignoring these unnoticed interactions could potentially cause failures that have never been systematically checked. Hence, it is beneficial for MFS identification approaches to identify these interactions. In order to account for these unnoticed interactions in CT, this study introduces the notion of pending schema, based on which a theoretical framework of CT schemas is established. In particular, we formally define the determinability of a schema in CT with respect to given information; as such, the yet-to-be determined schemas are exactly the pending schemas. The relationships between the different schemas (faulty, healthy, and pending) and test cases are also theoretically analyzed. Based on which, we further propose three formulas, along with three corresponding algorithms, for the identification of the pending schemas in failing test cases, and formally prove their correctness. As a result, we reduce the complexity of obtaining pending schemas with respect to the number of factors that may have influences on the software.

Datacenters receive dynamic workloads with disparate specifications to be scheduled on virtual machines (VMs). These unpredictable, alarmingly growing workloads with varying resource specifications may bring down the servers of datacenters into an imbalanced state. Thus, resulting in low resource utilization and high energy consumption among the servers. To cater to the need of fluctuating on-demand resource provisioning, it is essential to scale up the ability and capacityof existing infrastructure through virtualization. Moreover, due to the involvement of conflicting scheduling constraints, load scheduling in cloud computing fall under NP-hard problem. An effective scheduling mechanism in amalgamation with a load balancing strategy based on binary JAYA is implemented to alleviate the challenges as mentioned above. This technique not only improves resource utilization but also brings down the degree of energy consumption and makespan while keeping the whole system balanced. At first, it focuses on evoking a load balancing procedure to uniformly disperse the loads among VMs based on the compatibility between the tasks and VMs and secondly, JAYA algorithm is executed to find the best possible mapping of tasks onto VMs. In order to appraise the efficacy of the proposed algorithm, the scheduling of independent and non-preemptive tasks is simulated in CloudSim using a benchmark parallel workload by NASA-iPSC. Experiments are conducted in both homogenous and heterogeneous environments. The proposed algorithm is statistically validated using the Friedman test, followed by a Holm’s test. The proposed approach is compared over other algorithms such as Round Robin (RR), binary Particle Swarm Optimization (PSO) and Genetic Algorithm (GA). The simulation results show a notable amelioration over other mentioned algorithms by an increase of resource utilization with 18.47% (GA), 12.65% (BPSO) and 4.18% (GA), 2.51% (BPSO) and a reduction of makespan by 6.47% (GA), 4.35% (BPSO) and 4.17% (GA), 2.20% (BPSO) with an increasing number of tasks and VMs in two different test cases respectively.

The Industry 4.0 (I4.0) is a paradigm settled down by the introduction of the Internet of things (IoT) into the production and manufacturing environment. I4.0 promotes the connection of physical items such as sensors, devices, and enterprise assets, to each other and to the Internet. The information that flows through these items is vital because it serves to make relevant decisions. One of the main features of I4.0 is its adaptability to the human needs, this means that the items included in the I4.0 network are heterogeneous and they are large in number. The majority of I4.0 papers, which are focused on testing, describe a specific system or part of the I4.0 network. We have not found any paper that undertakes the testing of multiple connected IoT devices that will receive, process, and make decisions according to the complex and real data that travel through the network. In this article, we present IoT-TEG (Test Event Generator) 4.0, which is based on the test event generator system IoT-TEG . IoT-TEG 4.0 provides two new main contributions: the generation of test cases, which can include all the different types of data that the connected I4.0 devices under study can manage, and real-time testing. Additionally, its validation using real IoT programs is included and the results show that IoT-TEG 4.0 allows us to conduct tests that mimic real IoT system behaviors.

We propose a mathematical optimization model and its solution for joint chance constrained DC Optimal Power Flow. In this application, it is particularly important that there is a high probability of transmission limits being satisfied, even in the case of uncertain or fluctuating feed-in from renewable energy sources. In critical network situations where the network risks overload, renewable energy feed-in has to be curtailed by the transmission system operator (TSO). The TSO can reduce the feed-in in discrete steps at each network node. The proposed optimization model minimizes curtailment while ensuring that there is a high probability of transmission limits being maintained. The latter is modeled via (joint) chance constraints that are computationally challenging. Thus, we propose a solution approach based on the robust safe approximation of these constraints. Hereby, probabilistic constraints are replaced by robust constraints with suitably defined uncertainty sets constructed from historical data. The ability to discretely control the power feed-in then leads to a robust optimization problem with decision-dependent uncertainties, i.e. the uncertainty sets depend on decision variables. We propose an equivalent mixed-integer linear reformulation for box uncertainties with the exact linearization of bilinear terms. Finally, we present numerical results for different test cases from the Nesta archive, as well as for a real network. We consider the discrete curtailment of solar feed-in, for which we use real-world weather and network data. The experimental tests demonstrate the effectiveness of this method and run times are very fast. Moreover, on average the calculated robust solutions only lead to a small increase in curtailment, when compared to nominal solutions.

In continuous testing, developers execute automated test cases once or even several times per day to ensure the quality of the integrated code. Although continuous testing helps ensure the quality of the code and reduces maintenance effort, it also significantly increases test execution overhead. In this thesis, we empirically evaluate the effectiveness of test impact analysis from the perspective of code dependencies in the continuous testing setting. We first applied test impact analysis to one year of software development history in 11 large-scale open-source systems. We found that even though the number of changed files is small in daily commits (median ranges from 3 to 28 files), around 50% or more of the test cases are still impacted and need to be executed. Motivated by our finding, we further studied the code dependencies between source code files and test cases, and among test cases. We found that 1) test cases often focus on testing the integrated behaviour of the systems; 2) 18% of the test cases have dependencies with other test cases, and test case inheritance is the most common cause of test case dependencies; 3) We documented four dependency-related test smells that we uncovered in our manual study. Our study provides the first step towards studying and understanding the effectiveness of test impact analysis in the continuous testing setting and provides insights on improving test design and execution.

Testing of software is done with an intention to find faults. If a fault is there then it needs to be detected, located and then resolved. Fault detection and localization are adjoining activities and thus it is difficult to combine them. Fault detection requires test information that helps in detecting the faults early whereas fault localization requires information which helps in locating the faults accurately. But test information is one common thing that is required for both the activities. This pre-condition helps to effectively combine both fault detection and localization. In this research work, a code and mutant coverage based multi-objective approach has been proposed to produce a minimized test suite having the ability of both detecting and locating faults. For optimization of test cases, NSGA-II algorithm has been used. Results on the projects of Defects4j repository depicts that the proposed approach is able to produce minimized test suites having the capability of detecting 95.16% of faults and locating all detected faults with fault localization score almost equivalent to that of the complete test suite. The average percentage of reduction in test suite size is 78% which is a good reduction percentage with the given fault detection and localization scores.

Although the number of aspect-oriented software development techniques and tools proposed by the scientific literature have been increasing since the late 80′s, the evidence about the benefits that the aspect-oriented paradigm have reached in real-world settings is scarce. Our objective is to identify and classify the aspect-oriented software development methodologies used to reduce the effort and costs of moving from traditional approaches to the aspect-oriented approach in real-world settings. We conducted a systematic mapping study (SMS). Our search strategies retrieved a set of 3212 papers out of which 115 were selected as relevant studies. We defined eight categories to classify these studies: aspect-oriented methodologies proposed for early aspects; development early phases covered; notations; modeling techniques; supporting tools; aspect-oriented methodologies used in real-world settings; benefits reported and unsolved issues. As a result, 39 named methodologies were reported; they cover the business modeling (14 papers), requirements (93 papers), test cases (1 paper) and design (41 papers) phases of the software development life cycle (SDLC); we found 36 different notations, with UML as the most mentioned (66 papers); 22 modeling techniques were found, where the use cases were the ones that appeared the most, on 43 occasions; 43 support tools of which none was repeated in more than 3 articles; 15 applications in real-world settings; 17 benefits, modularization being the most mentioned with 4 occurrences; and 15 pending improvement opportunities. Finally, we have obtained conclusions: the literature analyzed demonstrates that there are no prevailing standards on methodologies and notations, beyond that the most employed are those belonging to the OMG; we have not found any methodology that includes all phases of the SDLC; the diagrams corresponding to OMG’s standards account for 78% of the results in the facet of modeling techniques; there are no tools that have the greatest predilection and the most used is mentioned only three times; in addition, 41% of the articles do not mention any tool; the evidence of aspect-oriented methodologies application in real-world settings reached just the 10%, although the declared benefits are coincident with those promised in the aspect-orientated literature. The mentioned pending issues can guide new studies (RQ8).

A robust deep learning model consisting of long short-term memory and fully connected neural networks has been proposed to automatically interpret homogeneous petroleum reservoirs having infinite, no flow, and constant pressure outer boundary conditions. The pressure change data recorded during the well test operation along with its derivative is input into the model to perform the classification for identifying the reservoir model and, further, regression to estimate output parameter. Gaussian noise was added to analytical models while generating the synthetic training data. The hyperparameters were regulated to perform model optimization, resulting in a batch size of 64, Adam optimization algorithm, learning rate of 0.01, and 80:10:10 data split ratio as the best choices of hyperparameters. The performance accuracy also increased with an increase in the number of samples during training. Suitable classification and regression metrics have been used to evaluate the performance of the models. The paper also demonstrates the prediction performance of the optimized model using simulated and actual oil well pressure drawdown test cases. The proposed model achieved minimum and maximum relative errors of 0.0019 and 0.0308, respectively, in estimating output for the simulated test cases and relative error of 0.0319 for the real test case.

Internet backbone refers to the principal data routes between large, strategically interconnected networks and core routers on the Internet. Internet backbone router is essentially the core router of Internet backbone and its performance is mainly relevant to the reliability of its mainboard. The mainboard is an embedded system consisting of hardware and software. Its reliability testing involves executing a number of test cases, which are designed to expose potential defects, under harsh environmental conditions. The testing process is largely prolonged due to the dramatic increase of the number of test cases, mainly due to the continuous increase and upgrade of its functional modules. Thus, there is a big demand from industry to improve the reliability testing efficiency and effectiveness. In this work, we exploit the principles of regression testing in software maintenance: test case selection and prioritization, and construct two testing planning models to largely reduce the testing time as well as to improve the effectiveness of failure detections. The former is a two-step model we introduced in previous work that optimizes test case selection and test case sequencing sequentially. The latter, an integrated model is newly developed, optimizing the test case selection and sequencing simultaneously with the precedence constraints among the test cases. Moreover, we propose exact algorithms based on branch-and-price for solving these two models. Finally, we present a case study demonstrating that the integrated model outperforms the two-step method and the advantage is more significant if the sequencing objective has greater weight in the integrated objective function.

This paper presents RTL-ConTest, a Register Transfer Level (RTL) security vulnerability detection algorithm, that extracts critical process flows from a RTL design and executes RTL-level concolic testing to generate security test cases for identifying critical exploits manifested in a System-on-Chip (SoC). The efficiency of the proposed approach is evaluated on open source RISC-V-based SoCs. Our technique is successful in detecting the security vulnerabilities manifested in the processor core as well as in the rest of the SoC, e.g., debug modules, peripherals, etc., thereby providing a thorough vulnerability check on the entire hardware design. As demonstrated by our experimental results, in circumstances where conventional security verification tools are limited, RTL-ConTest furnishes significantly improved efficiency in detecting SoC security vulnerabilities.

Knowing the effectiveness of a test suite is essential for many activities such as guiding the generation of new test cases and assessing the test adequacy of code. Mutation testing is a commonly used defect injection technique for evaluating the effectiveness of a test suite. However, it is usually computationally expensive, as a large number of mutants (buggy versions) are needed to be generated from a production code under test and executed against the test suite. In order to reduce the expensive testing cost, recent studies proposed to use supervised models to predict the effectiveness of a test suite without executing the test suite against the mutants. Nonetheless, the training of such a supervised model requires labeled data, which still depends on the costly mutant execution. Furthermore, existing models are based on traditional supervised learning techniques, which assumes that the training and testing data come from the same distribution. But, in practice, software systems are subject to considerable concept drifts, i.e. the same distribution assumption usually does not hold. This can lead to inaccurate predictions of a learned supervised model on the target code as time progresses. To tackle these problems, in this paper, we propose a Coverage-Based Unsupervised Approach (CBUA) for evaluating the effectiveness of a test suite. The whole process only requires a one-time execution of the test suite against the target production code, without involving any mutant execution and any training data. CBUA can ensure the score monotonicity property (i.e. adding test cases to a test suite does not decrease its mutation score), which may be violated by a supervised approach. The experimental results show that CBUA is very competitive to the state-of-the-art supervised approaches in terms of the prediction accuracy. Since CBUA is an easy-to-implement model with a low cost, we suggest that it should be used as a baseline approach for comparison when any novel prediction approach is proposed in future studies.

Testing a program to confirm whether it consistently implements its requirements specification is a necessary but time-consuming activity in software development. Automatic testing based on specifications can significantly alleviate the workload and cost, but faces a challenge of how to ensure that both the user's concerns in the specification and possible execution paths in the program are all covered. In this paper, we describe a new method, called "Vibration-Method" or simply "V-Method", for automatic generation of test cases and test oracle from model-based formal specifications, aiming to address this challenge. The proposed method is suitable for testing information systems in which rich data types are used. Supporting the principle of "divide and conquer", the method provides a specific technique for generating test cases based on functional scenarios defined in the specification, test case generation criteria, automatic test case generation algorithms, and a well-defined mechanism for deriving test oracle. We elaborate on the method by discussing how initial test cases can be automatically generated, how additional necessary test cases are produced using the "vibration" technique, and how a test oracle can be automatically derived for a group of test cases. We also describe a controlled experiment to evaluate the effectiveness of the method and discuss the important issues in relation to the performance and applicability of the method.

Industrial control systems (ICS) are the backbone for the implementation of cybersecurity solutions. They are susceptible to various attacks, due to openness in connectivity, unauthorized attempts, malicious attacks, use of more commercial off the shelf (COTS) software and hardware, and implementation of Internet protocols (IP) that exposes them to the outside world. Cybersecurity solutions for Information technology (IT) secured with firewalls, intrusion detection/protection systems do nothing much for Operational technology (OT) ICS. An innovative concept of using real operational technology network traffic-based testbed, for cyber-physical system simulation and analysis, is presented. The testbed is equipped with real-time attacks using in-house penetration test tool with reconnaissance, interception, and firmware analysis scenarios. The test cases with different real-time hacking scenarios are implemented with the ICS cyber test kit, and its industrial datasets are captured which can be utilized for Deep packet inspection (DPI). The DPI provides more visibility into the contents of OT network traffic based on OT protocols. The Machine learning (ML) techniques are deployed for cyber-attack detection of datasets from the cyber kit. The performance metrics such as accuracy, precision, recall, F1 score are evaluated and cross validated for different ML algorithms for anomaly detection. The decision tree (DT) ML technique is optimized with pruning method which provides an attack detection accuracy of 96.5%. The deep learning (DL) techniques has been used recently for enhanced OT intrusion detection performances.

Deep learning architectures can accurately model complex dynamics such as Inverse models of nonlinear systems. Their uses in the control context have been well-developed in the past forming a strong basis. However, the black-box nature of such techniques have limited its usability in real- world applications. This work aims to provide an auxiliary framework that combines intelligent data-based information with the conventional Predictive Control approach. By adding the inverse model signals to the closed-loop optimization search, the performance and accuracy are improved in our test cases. We provide a set of benchmark experiments as well as different optimization algorithms that benefit from Inverse models. Our results show a clear addition of Intelligent mechanisms to the standard methodology, without the uncertainties of black-box models and with all the advantages.

Objective Based on the hypothesis that adding a cross-modal and cross-attention (C2MA) mechanism into a deep learning network improves accuracy and efficacy of medical image segmentation, we propose to test a novel network to segment acute ischemic stroke (AIS) lesions from four CT perfusion (CTP) maps. Methods The proposed network uses a C2MA module directly to establish a spatial-wise relationship by using the multigroup non-local attention operation between two modal features and performs dynamic group-wise recalibration through group attention block. This C2MA-Net has a multipath encoder-decoder architecture, in which each modality is processed in different streams on the encoding path, and the pair related parameter modalities are used to bridge attention across multimodal information through the C2MA module. A public dataset involving 94 training and 62 test cases are used to build and evaluate the C2MA-Net. AIS segmentation results on the test cases are analyzed and compared with other state-of-the-art models reported in the literature. Results By calculating several average evaluation scores, C2MA-network improves Recall, F1, and F2 scores by 4.0%, 1.4%, and 3.0%, respectively. In the ablation experiment, the F1 score of C2MA-Net is at least 7.8% higher than that of single-input single-modal self-attention networks. Conclusion This study demonstrates advantages of applying C2MA-network to segment AIS lesions, which yields promising segmentation accuracy, and achieves semantic decoupling by processing different parameter modalities separately. Significance Proving the potential of cross-modal interactions in attention to assist identifying new imaging biomarkers for more accurately predicting AIS prognosis in future studies.

In an era of connectivity and automation, the vehicle industry is adopting numerous technologies to transform driver-centric vehicles into intelligent mechanical devices driven by software components. Software integration and network connectivity inherit numerous security issues that open the door for malicious attacks. Software security testing is a scalable and practical approach to identify systems’ weaknesses and vulnerabilities at an early stage and throughout their life-cycle. Security specialists recommend fuzz testing to identify vulnerabilities within vehicle software systems. Nevertheless, the randomness and blindness of fuzzing hinder it from becoming a reliable security tool. This article presents a vulnerability-oriented fuzz (VulFuzz) testing framework that utilizes security vulnerability metrics designed particularly for connected and autonomous vehicles to direct and prioritize the fuzz testing toward the most vulnerable components. While most gray-box fuzzing techniques aim solely to expand code coverage, the proposed approach assigns weights to ensure a thorough examination of the most vulnerable components. Moreover, we employ an input structure-aware mutation technique that can bypass vehicle software systems’ input formats to boost test performance and avoid dropped test cases. Such a testing technique will contribute to the quality assurance of vehicle software engineering. We implemented the proposed approach on OpenPilot, a driver assistance system, and compared our results to American fuzzy lop (AFL) and an unguided mutation-based fuzzer. Within 16.8 h, VulFuzz exposed 335 crashes, 41 times more than AFL and two times more than an unguided mutation-based fuzzer. VulFuzz is explicitly efficient for automotive systems, reaching the same code coverage as AFL but with more exposed crashes and fewer dropped messages.

It is important to encourage older adults to remain active when interacting with assistive robots. This study proposes a schematic model for integrating levels of automation (LOAs) and transparency (LoTs) in assistive robots to match the preferences and expectations of older adults. Metrics to evaluate LOA and LoT design combinations are defined. We develop two distinctive test cases to examine interaction design considerations for robots working for this population in everyday tasks: a person-following task with a mobile robot and a table-setting task with a robot manipulator. Evaluations in user studies with older adults reveal that LOA and LoT combinations influence interaction elements. Low LOA and high LoT encouraged activity engagement while receiving adequate information regarding the robot's behavior. The variety of objective and subjective metrics is essential to provide a holistic framework for evaluating the interaction.

Testing is more than simply demonstrating a program is correct. We must constantly challenge ourselves to make ourselves better. Likewise, we must also challenge our programs and our ideas. Testing is how we bring science into our craft and replace guesses and myths with real knowledge about how the world works. Building good tests can take a lot of time and effort, and Oracle databases present unique challenges for building reproducible test cases. Luckily, Oracle provides many tools to help us test, such as SQL, PL/SQL, the data dictionary, dynamic performance views, and much more.

When changes are performed on an automated production system (aPS), new faults can be accidentally introduced in the system, which are called regressions. A common method for finding these faults is regression testing. In most cases, this regression testing process is performed under high time pressure and on-site in a very uncomfortable environment. Until now, there is no automated support for finding and prioritizing system test cases regarding the fully integrated aPS that are suitable for finding regressions. Thus, the testing technician has to rely on personal intuition and experience, possibly choosing an inappropriate order of test cases, finding regressions at a very late stage of the test run. Using a suitable prioritization, this iterative process of finding and fixing regressions can be streamlined and a lot of time can be saved by executing test cases likely to identify new regressions earlier. Thus, an approach is presented in this paper that uses previously acquired runtime data from past test executions and performs a change identification and impact analysis to prioritize test cases that have a high probability to unveil regressions caused by side effects of a system change. The approach was developed in cooperation with reputable industrial partners active in the field of aPS engineering, ensuring a development in line with industrial requirements. An industrial case study and an expert evaluation were performed, showing promising results., 13 pages, https://ieeexplore.ieee.org/abstract/document/8320514/

Agile methods and their practices have fostered the widespread presence of automated test cases. Such test cases have been successfully and extensively adopted to test different software levels, from unit tests (e.g., JUnit) to end-to-end Web Graphical User Interface (GUI) tests (e.g., Selenium Webdriver). While test execution is mostly automated by existing tools, test design remains a manual task. In the pursuit of a more automated test case generation approach, the use of models has been advocated by the model-based testing (MBT) technique. Current MBT approaches assume a top-down workflow in which testers design models, test cases are generated from models, and then scripts are written to automate test execution. Nevertheless, writing automated tests is nowadays a developer’s responsibility and testers face a scenario in which automated tests might be reused to produce new model-based tests. This paper aimed to improve the synergy between existing automated tests and MBT. To do so, we present an approach that infers a model from existing tests, a tester leverages this model to include new tests, and then test code is generated. We analyzed the proposed approach in the context of Web applications with system-level GUI tests that employ the Page Object pattern. For MBT, we adopted event-driven models augmented with parameters and test input data. We evaluated the approach’s applicability with a prototype tool called MoLeWe and an experimental study with nine open-source Web applications. The results provide some evidence that using MoLeWe may help to include new tests faster than manually coding them, while increasing the overall code coverage of the test suite.

Three different structural engineering designs were investigated to determine optimum design variables, and then to estimate design parameters and the main objective function of designs directly, speedily, and effectively. Two different optimization operations were carried out: One used the harmony search (HS) algorithm, combining different ranges of both HS parameters and iteration with population numbers. The other used an estimation application that was done via artificial neural networks (ANN) to find out the estimated values of parameters. To explore the estimation success of ANN models, different test cases were proposed for the three structural designs. Outcomes of the study suggest that ANN estimation for structures is an effective, successful, and speedy tool to forecast and determine the real optimum results for any design model.

Stochastic unit commitment is an efficient method for grid operation in the presence of significant uncertainties. An example is an operation during a predicted hurricane with uncertain line out-ages. However, the solution quality comes at the cost of substantial computational burden, which makes its adoption challenging. This paper evaluates some possible ways that machine learning can be used to reduce this computational burden. First, a set of feasibility studies is conducted. Results suggest that using machine learning as an assistant to the stochastic unit commitment solver is more advantageous than using it as a standalone solver. In particular, the machine learning model is trained to facilitate solving the problem by determining the unnecessary constraints that can be removed from the original problem without affecting the final accuracy. The variables that can be used as input features/predictors or outputs for the machine learning model are determined through feasibility studies. Then, an algorithm to train and utilize a machine learning model is proposed. The method is tested on a 500-bus synthetic South Carolina system. Various test cases show an average reduction in solution time by more than 90% by using the trained machine learning model to assist the stochastic unit commitment solver.

There is a need for simple, fast, and memory-efficient multidimensional data structures for dense and sparse storage that arise with numerical methods and in software applications. The data structures must perform equally well across multiple computer architectures, including CPUs and GPUs. For this purpose, we developed MATAR, a C++ software library that allows for simple creation and use of intricate data structures that is also portable across disparate architectures using Kokkos. The performance aspect is achieved by forcing contiguous memory layout (or as close to contiguous as possible) for multidimensional and multi-size dense or sparse MATrix and ARray (hence, MATAR) types. Our results show that MATAR has the capability to improve memory utilization, performance, and programmer productivity in scientific computing. This is achieved by fitting more work into the available memory, minimizing memory loads required, and by loading memory in the most efficient order. This document describes the purpose of the work, the implementation of each of the data types, and the resulting performance both in some simple baseline test cases and in an application code.

Testing is the process of evaluating a system by manual or automated means. While Regression Test Selection (RTS) discards test cases and Test Suite Minimization (TSM) shows diminution in fault detection rate, Test Case Prioritization (TCP) does not discard test cases. Test Case Prioritization techniques can be coverage or historical information based or model based. It can also be cost-time aware or requirement-risk aware. GUI/Web applications need special prioritization mechanism. In this paper, 90 scholarly articles ranging from 2001 to 2018 have been reviewed. We have explored IEEE, Wiley, ACM Library, Springer, Taylor & Francis and Elsevier database. We have also described each prioritization method with their findings and subject programs. This paper includes a chronological catalogue listing of the reviewed papers. We have framed three research questions which sum up the frequently used prioritization metrics, regularly used subject programs and the distribution of different prioritization techniques. To the best of our knowledge, this is the first review with a detail report of the last 18 years of TCP techniques. We hope this article will be beneficial for both beginners and seasoned professionals.

Today, continuous integration (CI) is state of the art for agile software practices. Teams can choose from a range of tools, such as Jenkins, Atlassian Bamboo, and Microsoft Azure DevOps, that facilitate CI, from build servers to deployment platforms. For pure software solutions and where hardware can be virtualized, CI is relatively easy to achieve thanks to fully automated testing. It becomes significantly harder for systems involving hardware that have to be interacted with when executing test cases.

The universal verification methodology (UVM) testbench utilizes the bus interface to access the design under verification (DUV) and registers using constraint random access. The UVM testbench is not able to perform cross-platform reusable verification. Alone UVM libraries are non-efficient for cross-platform migration, and individual C package modules are prone to miss corner cases with lower functional coverage. Thus, conventional UVM testbench needs a C test module for target-specific implementation. This work targets the implementation of hybrid UVM-C testbench architecture to potentially implement the auto-survivor path generation on higher integration. This paper proposes the UVM-C testbench model is capable of creating reusable test cases for design and registers with cross-platform communication. The new automation helps in the extraction of input parameters to implement script-based auto-covergroups and basic assertions to improvise functional coverage. The proposed UVM-C model implementation reduces the processing time, module capture value, and simulation time compared to state-of-the-art SystemVerilog and UVM verification methodologies. The method refines the processing time and simulation time by 16.41% and 15.23% as compared to SystemVerilog, while the improvement is 7.89% and 7.44% from UVM. The work also provides an average simulation instance value improvement of 11 per module per testbench run as compared to sole conventional UVM testbench.

Test-driven development (TDD) is an agile development technology that involves the running of many test cases. The software is likely to be more robust when more test cases are executed in a certain time. For this, it is important to find the combination of number of threads and test cases which can lead to the lowest average running time of a single test case aiming at different computers. It can improve the performance of TDD. Therefore, this paper proposed a method for this problem. First, it tests the three-dimensional raw data in computers with different cores. Second, these data are changed into two-dimensional data after dimensionality reduction. This facilitates the generation of fitting functions. Also, the fitting function of new data waiting for prediction is generated after dimensionality reduction. At last, similarity calculations between the fitting functions of raw and new data are carried out by using Euclidean distance similarity algorithms. Experimental results show that data based on dual-core computer have higher similarities with four new data, such as 81.25%, 100%, 81.25%, and 100%. Thus, the data of dual-core computer have higher reference credibility in predicting the average running time of a single test case of the new data for different computers. In summary, the performance of TDD can be improved after applying the proposed method.

REST web services are widely popular in industry, and search techniques have been successfully used to automatically generate system-level test cases for those systems. In this article, we propose a novel mutation operator which is designed specifically for test generation at system-level, with a particular focus on REST APIs. In REST API testing, and often in system testing in general, an individual can have a long and complex chromosome. Furthermore, there are two specific issues: (1) fitness evaluation in system testing is highly costly compared with the number of objectives (e.g., testing targets) to optimize for; and (2) a large part of the genotype might have no impact on the phenotype of the individuals (e.g., input data that has no impact on the execution flow in the tested program). Due to these issues, it might be not suitable to apply a typical low mutation rate like 1/ n (where n is the number of genes in an individual), which would lead to mutating only one gene on average. Therefore, in this article, we propose an adaptive weight-based hypermutation, which is aware of the different characteristics of the mutated genes. We developed adaptive strategies that enable the selection and mutation of genes adaptively based on their fitness impact and mutation history throughout the search. To assess our novel proposed mutation operator, we implemented it in the EvoMaster tool, integrated in the MIO algorithm, and further conducted an empirical study with three artificial REST APIs and four real-world REST APIs. Results show that our novel mutation operator demonstrates noticeable improvements over the default MIO. It provides a significant improvement in performance for six out of the seven case studies, where the relative improvement is up to +12.09% for target coverage, +12.69% for line coverage, and +32.51% for branch coverage.

The regression testing is a software-based testing approach executed to verify that changes made to the softwaredo not affect the existing functionality of the product. On account of the constraints of time and cost, it isimpractical to re-execute all the test cases for software whenever a change occurs. In order to overcome sucha problem in the selection of regression test cases, a prioritization technique should be employed. On the basisof some predefined criterion, the prioritization techniques create an execution schedule for the test cases, sothe higher priority test cases can be performed earlier than the lower priority test cases in order to improvethe efficiency of the software testing. Many prioritization criteria for regression test cases have been proposedin software testing literature; however, most of such techniques are code-based. Keeping in view this fact, thisresearch work has proposed a prioritization approach for regression test cases generated from software specificationswhich are based on the criterion of the Average Percentage Transition Coverage (APTC) by using arevised genetic algorithm. This criterion evaluates the rate of transitions coverage by incorporating knowledgeabout the significance of transitions between activates in the form of weights. APTC has been used as a fitnessevaluation function in a genetic algorithm to measure the effectiveness of a test cases sequence. Moreover, inorder to improve the coverage percentage, the proposed approach has revised the genetic algorithm by solvingthe problem of the optimal local solution. The experimental results show that the proposed approach demonstratesa good coverage performance with less execution time as compared to the standard genetic algorithmand some other prioritization techniques.

A new modification of multi-CNN ensemble training is investigated by combining multiloss functions from state-of-the-art deep CNN architectures for leaf image recognition. We first apply the U-Net model to segment leaf images from the background to improve the performance of the recognition system. Then, we introduce a multimodel approach based on a combination of loss functions from the EfficientNet and MobileNet (called as multimodel CNN (MMCNN)) to generalize a multiloss function. The joint learning multiloss model designed for leaf recognition allows each network to perform its task and cooperate with the others simultaneously, where knowledge from various trained deep networks is shared. This cooperation-proposed multimodel is forced to deal with more complicated problems rather than a simple classification. Therefore, the network can learn much rich information and improve its generalization capability. Furthermore, a multiloss trade-off strategy between two deep learning models can reduce the effect of redundancy problems in ensemble classifiers. The performance of our approach is evaluated by our custom Vietnamese herbal leaf species dataset, and public datasets such as Flavia, Leafsnap, and Folio are used to build test cases. The results confirm that our approach enhances the leaf recognition performance and outperforms the current standard single networks while having less low computation cost.

With a rapid growth in the deployment of renewable and distributed energy resources (DERs) in active power distribution networks, especially the inverter-interfaced distributed generators (IIDGs), existing fault section estimation methods are facing additional challenges. This paper proposes an optimization model for fault diagnoses in active power distribution systems, which aims at simultaneous identifications of suspected fault line sections and potential false alarms sent by remote fault indicators (RFIs). First, mathematical expressions of expected and false alarms of oriented RFIs (ORFIs) and non-oriented RFIs (NRFIs) are formulated to construct a basic fault diagnosis model. Minimizing the number of false alarms is chosen as the objective function to find the most credible one from all possible fault hypotheses which represent different combinations of elements in the outage area. Next, considering IIDGs, a modified fault diagnosis model is established by eliminating misleading components from the objective function which are produced by incompetent RFIs and have failed to detect weak currents. The monitoring data provided by distribution level phasor measurement units (D-PMUs) for weak IIDG fault currents are leveraged to construct the equivalent RFI current, which is compared with the trigger threshold to find incompetent sensors. The proposed problem is formulated as a mixed-integer linear programming (MILP) model, which is solved by off-the-shelf commercial solvers. The effectiveness of the proposed fault diagnosis model is validated by test cases representing several DERs and false alarms applied to a utility feeder.

We propose a novel multi-dimensional integration algorithm using a machine learning (ML) technique. After training a ML regression model to mimic a target integrand, the regression model is used to evaluate an approximation of the integral. Then, the difference between the approximation and the true answer is calculated to correct the bias in the approximation of the integral induced by a ML prediction error. Because of the bias correction, the final estimate of the integral is unbiased and has a statistically correct error estimation. The performance of the proposed algorithm is demonstrated on six different types of integrands at various dimensions and integrand difficulties. The results show that, for the same total number of integrand evaluations, the new algorithm provides integral estimates with more than an order of magnitude smaller uncertainties than those of the VEGAS algorithm in most of the test cases., 17 pages, 1 figure

This work presents a three-phase unbalanced continuation power flow algorithm for voltage stability assessment of distribution systems with high penetration of distributed energy resources (DERs). Analyzing distribution system voltage stability with DER will allow high penetration of renewable energy necessary for the sustainability goals. The developed algorithm can analyze voltage stability for both the meshed and radial systems and the balanced and unbalanced three-phase distribution systems. The developed tool allows the voltage stability analysis to facilitate the planning, operation, control, and distribution system management. The impact of DER on the voltage stability of several test cases has been analyzed considering constant power ( $PQ$ ) and regulated-voltage ( $PV$ ) modes of operation for DER units. Moreover, different voltage stability case studies are presented to demonstrate the impact of unbalance, load increment, and network topology on the maximum loading capacity. Results using the IEEE 13-node feeder, the 18-bus balanced shipboard system, the 13-node CIGRE benchmark system, and the 136-bus redial distribution feeder demonstrate that the developed continuation power flow tool can efficiently perform voltage stability analysis for active distribution systems.

Machine learning (ML) has great potential in automated code vulnerability discovery. However, automated discovery application driven by off-the-shelf machine learning tools often performs poorly due to the shortage of high-quality training data. The scarceness of vulnerability data is almost always a problem for any developing software project during its early stages, which is referred to as the cold-start problem. This article proposes a framework that utilizes transferable knowledge from pre-existing data sources. In order to improve the detection performance, multiple vulnerability-relevant data sources were selected to form a broader base for learning transferable knowledge. The selected vulnerability-relevant data sources are cross-domain, including historical vulnerability data from different software projects and data from the Software Assurance Reference Database (SARD) consisting of synthetic vulnerability examples and proof-of-concept test cases. To extract the information applicable in vulnerability detection from the cross-domain data sets, we designed a deep-learning-based framework with Long-short Term Memory (LSTM) cells. Our framework combines the heterogeneous data sources to learn unified representations of the patterns of the vulnerable source codes. Empirical studies showed that the unified representations generated by the proposed deep learning networks are feasible and effective, and are transferable for real-world vulnerability detection. Our experiments demonstrated that by leveraging two heterogeneous data sources, the performance of our vulnerability detection outperformed the static vulnerability discovery tool Flawfinder . The findings of this article may stimulate further research in ML-based vulnerability detection using heterogeneous data sources.

IoT devices usually have resource limitations and are prone to compromise. They are not well equipped with extra controls to promote their security. Green IoT (GIoT) devices are even more conservative in spending their resources. An effective way of promoting GIoT security at a low cost is removing program vulnerabilities. Fuzzing is a promising technique that exposes bugs in IoT programs. To evaluate a fuzzer performance, we make it run the test programs from some corpora to show its ability in detecting bugs. However, the contexts of bugs are not provided by the existing corpora, which may mislead the evaluation. Due to the complex logic of real-world programs, especially the GIoT ones, it is hard to obtain the bugs context. In this research, we propose to synthesize programs based on road-rock features that protect bugs from being exposed. Accordingly, we design a framework to generate a corpora that provide us with the contexts of bugs for more comprehensive fuzzing evaluation. As a case study, we evaluate AFL and AFLFast by using the synthesized corpora. The results show that AFLFast has the weakness of cycle explosion , which prevents fuzzing from examining more test cases. We developed AFLFast+ to overcome this issue.

Over the course of this year, more than a billion people have been afflicted by the COVID-19 outbreak. As long as individuals maintain their social distance, they should all be secure at this period. Because of this, there has been a rise in the usage of different online technologies, but at the same time, there has also been a rise in the likelihood of different cyber-attacks. A DDoS assault, the most prevalent and deadly of them all, impairs an online resource for its users. Thus, in this paper, we have proposed a filtering approach that can work efficiently in the COVID-19 scenario and detect the DDoS attack. We base our proposed approach on statistical methods like packet score and entropy variation for the identification of DDoS attack traffic. We have implemented our proposed approach on Omnet++ and for testing its efficiency we have checked it with different test cases. Our proposed approach detects the DDoS attack traffic with 96% accuracy and can also clearly have differentiated the DDoS attack traffic from the flash crowd.

Accurate force fields are necessary for predictive molecular simulations. However, developing force fields that accurately reproduce experimental properties is challenging. Here, we present a machine learning directed, multiobjective optimization workflow for force field parameterization that evaluates millions of prospective force field parameter sets while requiring only a small fraction of them to be tested with molecular simulations. We demonstrate the generality of the approach and identify multiple low-error parameter sets for two distinct test cases: simulations of hydrofluorocarbon (HFC) vapor-liquid equilibrium (VLE) and an ammonium perchlorate (AP) crystal phase. We discuss the challenges and implications of our force field optimization workflow.

We propose the deep Lagrange method (DLM), which is a new optimization method, in this study. It is based on a deep neural network to solve optimization problems. The method takes the advantage of deep learning artificial neural networks to find the optimal values of the optimization function instead of solving optimization problems by calculating sensitivity analysis. The DLM method is non-linear and could potentially deal with nonlinear optimization problems. Several test cases on sizing optimization and shape optimization are performed, and their results are then compared with analytical and numerical solutions.

JavaScript is one of the most used programming languages for front-end development of Web applications. The increase in complexity of front-end features brings concerns about performance, especially the load and execution time of JavaScript code. In this paper, we propose an evolutionary program improvement technique to reduce the size of JavaScript programs and, therefore, the time required to load and execute them in Web applications. To guide the development of this technique, we performed an experimental study to characterize the patches applied to JavaScript programs to reduce their size while keeping the functionality required to pass all test cases in their test suites. We applied this technique to 19 JavaScript programs varying from 92 to 15,602 LOC and observed reductions from 0.2 to 73.8 percent of the original code, as well as a relationship between the quality of a program’s test suite and the ability to reduce the size of its source code.

Merchant ship-radiated noise, recorded on a single receiver in the 360-1100 Hz frequency band over 20 min, is employed for seabed classification using an ensemble of deep learning (DL) algorithms. Five different convolutional neural network architectures and one residual neural network are trained on synthetic data generated using 34 seabed types, which span from soft-muddy to hard-sandy environments. The accuracy of all of the networks using fivefold cross-validation was above 97%. Furthermore, the impact of the sound speed and water depth mismatch on the predictions is evaluated using five simulated test cases, where the deeper and more complex architectures proved to be more robust against this variability. In addition, to assess the generalizability performance of the ensemble DL, the networks were tested on data measured on three vertical line arrays in the Seabed Characterization Experiment in 2017, where 94% of the predictions indicated that mud over sand environments inferred in previous geoacoustic inversions for the same area were the most likely sediments. This work presents evidence that the ensemble of DL algorithms has learned how the signature of the sediments is encoded in the ship-radiated noise, providing a unified classification result when tested on data collected at-sea.

In the field of information technology, the gesture recognition system plays a very essential role. As it has achieved vast importance, it is mandatory to test the recognition system to ensure the quality of the system by identifying the bugs in the software. In our research, we suggested a dynamic testing method for gesture recognition software. using dynamic image pattern generation with augmentation. The automated software testing framework is a set of processes to create new test cases for properly testing a image processing software. The research intention for generate automated testing cases by following a standard process which helps to increase the performance and efficiency of the gesture recognition system. We have built the framework to give proper testing and give result (accuracy and defect) for which gesture recognition system already in the market. our research, the team strongly following and adding two software testing standard. First one is ISO/IEC/IEEE/291129-3 to define the process for testing software. And the second one is ISO/IEC/IEEE/291129-5 to implement the techniques for software testing. We proposed this framework with major five parameters by noise, rotation, background, contrast, and scale. Which are the most use with every gesture recognition system. Our developed framework’s phase is used to generate new testing cases based on the existing gesture recognition system’s data. There are we work with five systems, commonly with the gesture recognition for experiments. We provide the testing report with total accuracy and defect by comparing existing well-known system’s data. At the final result, our system suggested an analysis report based on the testing result. And tell what are the improvement needs for the existing system to consider noised images or different scaled images to build a robust system. GUB JOURNAL OF SCIENCE AND ENGINEERING, Vol 7, Dec 2020 P 42-50

Practical application of deep learning based non-intrusive load monitoring (NILM) system requires the deep neural network model to generalize on new unseen data. Existing NILM solutions are not suitable for real-world application due to their poor disaggregation accuracy on new unseen data. In order to address this problem, this paper presents a NILM algorithm that uses data augmentation to generate synthetic data for training deep convolutional neural network models for each target appliance. Proposed data augmentation technique works by combining on and off-durations of a target appliance from various datasets, and forms a unified and comprehensive synthetic aggregate and sub-meter profiles. Apart from proposed algorithm, this paper also proposes an evaluation approach that relies on total predicted energy and ground-truth energy of an appliance to provide detailed insights about total overlapping energy, missing energy and extra energy predicted by the algorithm. Comparison results on our proposed evaluation approach showed that proposed disaggregation algorithm was able to predict energy that was 60% overlapping with ground truth energy and 36% energy was extra. Overall results showed that overlapping energy was 2.5 times more, and extra-predicted energy was 60% less than state-of-the-art algorithms in unseen test cases.

The installation of Phasor Measurement Units (PMUs) is a step towards achieving wide-area situational awareness for the power grid. PMUs utilize GPS signals for time synchronization and are vulnerable to GPS Spoofing Attacks (GSAs) as civilian GPS signals are unencrypted and have low signal power. We propose a novel Residual-based Spoofing Detection and Measurement Correction (RSDMC) algorithm for the power grid that detects GSAs and corrects spoofed PMU measurements. During one or multiple GSAs, RSDMC iteratively minimizes the residual norm to correct spoofed PMU measurements. We derive a necessary condition for our proposed algorithm to show that the residual norm increases during GSAs. We perform Monte Carlo simulations to verify our derived necessary condition. We further simulate the IEEE 14, IEEE 118, and Illinois 200 bus test cases to validate RSDMC against multiple GSAs.

The security-constrained optimal power flow (SCOPF) is fundamental in power systems and connects the automatic primary response (APR) of synchronized generators with the short-term schedule. Every day, the SCOPF problem is repeatedly solved for various inputs to determine robust schedules given a set of contingencies. Unfortunately, the modeling of APR within the SCOPF problem results in complex large-scale mixed-integer programs, which are hard to solve. To address this challenge, leveraging the wealth of available historical data, this paper proposes a novel approach that combines deep learning and robust optimization techniques. Unlike recent machine-learning applications where the aim is to mitigate the computational burden of exact solvers, the proposed method predicts directly the SCOPF implementable solution. Feasibility is enforced in two steps. First, during training, a Lagrangian dual method penalizes violations of physical and operations constraints, which are iteratively added as necessary to the machine-learning model by a Column-and-Constraint-Generation Algorithm (CCGA). Second, another different CCGA restores feasibility by finding the closest feasible solution to the prediction. Experiments on large test cases show that the method results in significant time reduction for obtaining feasible solutions with an optimality gap below 0.1%.

Introduction This study aims to evaluate deep learning (DL)‐based artificial intelligence (AI) techniques for detecting the presence of breast cancer on a digital mammogram image. Methods We evaluated several DL‐based AI techniques that employ different approaches and backbone DL models and tested the effect on performance of using different data‐processing strategies on a set of digital mammographic images with annotations of pathologically proven breast cancer. Results Our evaluation uses the area under curve (AUC) and accuracy (ACC) for performance measurement. The best evaluation result, based on 349 test cases (930 test images), was an AUC of 0.8979 [95% confidence interval (CI) 0.873, 0.923] and ACC of 0.8178 [95% CI 0.785, 0.850]. This was achieved by an AI technique that utilises a certain family of DL models, namely ResNet, as its backbone, combines the global features extracted from the whole mammogram and the local features extracted from the automatically detected cancer and non‐cancer local regions in the whole image, and leverages background cropping and text removal, contrast adjustment and more training data. Conclusion DL‐based AI techniques have shown promising results in retrospective studies for many medical image analysis applications. Our study demonstrates a significant opportunity to boost the performance of such techniques applied to breast cancer detection by exploring different types of approaches, backbone DL models and data‐processing strategies. The promising results we have obtained suggest further development of AI reading services could transform breast cancer screening in the future.

Video surveillance is a crucial part of public safety and security systems. State-of-the-art techniques either use back-tracing for owner identification or there is no provision of reporting ownership of the abandoned objects. We provide a novel object association technique which very elegantly tackles this issue. We propose a convolution neural network based framework for abandoned object localization and owner identification in video surveillance systems that performs exceptionally well on publicly available datasets and our newly developed dataset. For testing the usability and robustness of these systems, an extensive set of test cases is a prerequisite, to this end we provide an elaborate surveillance dataset covering many complex cases which are not available in existing datasets. Also, the developed dataset has been tested with various state-of-the-art techniques, showing the complexity and challenging nature of the cases. Results obtained from the proposed framework are highly motivating as it provides event detection along with the time of abandonment and ownership information, which can help further investigation and prevent unwanted incidents.

This article lists the basic crystallographic equations underlying molecular-replacement software. The prospects for future developments are considered, and a brief account of past progress is included., This article provides an introduction to the crystal phasing technique known as molecular replacement. The available software is reviewed, and the prospects for future developments are considered. Several examples are described in detail to illustrate potential problems. A brief account of past progress is included. The basic crystallographic equations underlying the procedures are given in an appendix.

The peculiarities of software product testing processes while working in the Scrum-team were studied. The types of testing characteristic of the flexible testing technique are singled out, that make it possible to make the testing process constantly integrated into teamwork, both at the stage of requirements formation and design, and at the stage of coding and generation of test sets. This is possible by making the tester's recommendations in the process of creating user stories, planning the release of the software version in terms of testing and defects, planning a sprint based on user stories and defects, performing a sprint with continuous testing, regression testing after sprint ends and reporting of results of testing. The article highlights the stages of the flexible testing process in the Scrum team. It is proposed to automate the process of flexible testing for a training team project in the Visual Studio software environment based on Team Foundation Server. Author demonstrates an example of automation of the process of flexible testing by dividing it into four quadrants to comply with the principles of working on a flexible methodology of software development. In the first quadrant there is a study of the quality of the internal code of the software product, the modular testing. To implement modular testing in Visual Studio, a new solution is created in order to generate a class for testing, where the conditions for testing are prescribed in the body of the class. The second quadrant implements the principles of system testing. At this stage the features of creating such a test artifact as test cases are demonstrated. That provides for the fulfillment of certain conditions to verify the functionality of the developing software product; linking between created test cases to user stories presented as team project tasks Product Backlog. The study demonstrates an example of manual testing using a special tool Microsoft Test Manager, which allows you to create plans, add and update test cases, perform manual tests. In the third quadrant, it was performed a trial test in Microsoft Test Manager and it was created another test artifact - error reports. The fourth quadrant automatically tests non-functional software requirements.

The digital transformation of all the conventional systems in the field, such as healthcare, transportation and education, has led to the massive outflow of data. The bulk of data generated by the digital devices is challenging to handle, resulting in latency issues while provisioning services to the end-users. To address this issue, a promising solution is provided by osmotic computing, which exploits as well as integrates cloud, edge, and Internet of things platforms. Osmotic computing is a growing research domain that has laid the foundation of a new state-of-the-art computing paradigm by objectifying the scenarios for handling hefty data and computations according to user’s requirement and resource availability. However, the eclectic range of computational resources and services available between datacenters of different platforms in the federated environment is a tedious task to manage. In this paper, we propose a task mapping algorithm by incorporating osmotic computing principles to complete the tasks in latency-sensitive systems. We present an osmotic task manager, which aims to optimize the mapping decisions for all the services based on two-fold categorization, namely task-level categorization and processing-level categorization. The objective is to categorize all the incoming requests on the basis of their resource requirement and efficient mapping of the tasks to resources. The proposed algorithm is simulated and evaluated using various synthetic test cases to show its efficacy.