Method Overriding Research Articles

Automated checker for detecting method-hiding in Java programs

Method overriding is a valuable mechanism that happens when an instance method is defined in a subclass and has the same signature and return type as an instance method in the superclass. However, in Java, if those methods are static, then instead method hiding happens, which is a programming weakness and may produce unexpected results. Static analysis is an approach in software testing that examines code to identify various programming weaknesses throughout the software de velopment process without running it. This paper addresses the detection of method-hiding problem in Java programs. We implemented a new automated checker under the SpotBugs static analysis tool that can detect the mentioned problem. According to our results, the checker precisely detected zhe related issues in both custom test cases and realword programs.

From Inheritance to Mockito: An Automatic Refactoring Approach

Unit testing focuses on verifying the functions of individual units of a software system. It is challenging due to the high inter dependencies among software units. Developers address this by mocking—replacing the dependency by a “fake” object. Despite the existence of powerful, dedicated mocking frameworks, developers often turn to a “hand-rolled” approach—inheritance. That is, they create a subclass of the dependent class and mock its behavior through method overriding. However, this requires tedious implementation and compromises the design quality of unit tests. This work contributes a fully automated refactoring framework to identify and replace the usage of inheritance by using Mockito—a well received mocking framework. Our approach is built upon the empirical experience from <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">five</i> open source projects that use inheritance for mocking. We evaluate our approach on <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">nine</i> other projects. Results show that our framework is efficient, generally applicable to new datasets, mostly preserves test case behaviors in detecting defects (in the form of mutants), and decouples test code from production code. The qualitative evaluation by experienced developers suggests that the auto-refactoring solutions generated by our framework improve the quality of the unit test cases in various aspects, such as making test conditions more explicit, as well as improved cohesion, readability, understandability, and maintainability with test cases. Finally, we submit 23 pull requests containing our refactoring solutions to the open source projects. It turns our that, 9 requests are accepted/merged, 6 requests are rejected, the remaining requests are pending (5 requests), with unexpected exceptions (2 requests), or undecided (1 request). In particular, among the 21 open source developers that are involved in the reviewing process, 81% give positive votes. This indicates that our refactoring solutions are quite well received by the open source projects and developers.

КРИТЕРІЇ БЕНЧМАРКІНГОВОГО ДОСЛІДЖЕННЯ ЗІСТАВНИХ КОМПАНІЙ ДЛЯ ЗАСТОСУВАННЯ МЕТОДУ ЧИСТОГО ПРИБУТКУ ТРАНСФЕРТНОГО ЦІНОУТВОРЕННЯ

The article analyzes the statutory requirements for the criteria to select comparable companies in the framework of building the range of profitability of independent companies, which corresponds to the principle of “arm’s length”. Among the five transfer pricing methods used to analyze the compliance of controlled transactions with the principle of “arm’s length”, the net profit method is the most popular (except for credit transactions and transactions involving intangible assets, which are not discussed in this article). This is a logical result of a gradual overriding of methods depending on the availability of the necessary sources of comparable information because only the net profit method allows the application of external information on the profitability of comparable enterprises, which can be obtained from public sources – usually professional commercial databases. The main challenge in using such databases, however, is to determine the optimal approach to selecting comparable companies, and mainly to build a robust company selection strategy that simultaneously finds a network of as many comparable companies as possible and meets the requirements of the tax law. Possible databases that can be used for benchmarking research are identified, and a roadmap for the step-by-step application of the criteria for selecting comparable companies is proposed. The practical example of the application of the proposed selection criteria and recommendations on solving typical problems during the analysis, improvement of the selected quality based on the requirements of the Tax Code of Ukraine and public sources of information are given. The results of this article may be of practical value for enterprises engaged in controlled transactions and being the objects of transfer pricing in Ukraine.

Type unsoundness in practice: an empirical study of Dart

The type system in the Dart programming language is deliberately designed to be unsound: for a number of reasons, it may happen that a program encounters type errors at runtime although the static type checker reports no warnings. According to the language designers, this ensures a pragmatic balance between the ability to catch bugs statically and allowing a flexible programming style without burdening the programmer with a lot of spurious type warnings. In this work, we attempt to experimentally validate these design choices. Through an empirical evaluation based on open source programs written in Dart totaling 2.4 M LOC, we explore how alternative, more sound choices affect the type warnings being produced. Our results show that some, but not all, sources of unsoundness can be justified. In particular, we find that unsoundness caused by bivariant function subtyping and method overriding does not seem to help programmers. Such information may be useful when designing future versions of the language or entirely new languages.

A proof system for adaptable class hierarchies

The code base of a software system undergoes changes during its life time. For object-oriented languages, classes are adapted, e.g., to meet new requirements, customize the software to specific user functionalities, or refactor the code to reduce its complexity. However, the adaptation of class hierarchies makes reasoning about program behavior challenging; even classes in the middle of a class hierarchy can be modified. This paper develops a proof system for analyzing the effect of operations to adapt classes, in the context of method overriding and late bound method calls. The proof system is incremental in the sense that reverification is avoided for methods that are not explicitly changed by adaptations. Furthermore, the possible adaptations are not unduly restricted; i.e., flexibility is retained without compromising on reasoning control. To achieve this balance, we extend the mechanism of lazy behavioral subtyping, originally proposed for reasoning about inheritance when subclasses are added to a class hierarchy, to deal with the more general situation of adaptable class hierarchies and changing specifications. The reasoning system distinguishes guaranteed method behavior from requirements toward methods, and achieves incremental reasoning by tracking guarantees and requirements in adaptable class hierarchies. We show soundness of the proposed proof system.

Secure the Clones

Exchanging mutable data objects with untrusted code is a delicate matter because of the risk of creating a data space that is accessible by an attacker. Consequently, secure programming guidelines for Java stress the importance of using defensive copying before accepting or handing out references to an internal mutable object. However, implementation of a copy method (like clone()) is entirely left to the programmer. It may not provide a sufficiently deep copy of an object and is subject to overriding by a malicious sub-class. Currently no language-based mechanism supports secure object cloning. This paper proposes a type-based annotation system for defining modular copy policies for class-based object-oriented programs. A copy policy specifies the maximally allowed sharing between an object and its clone. We present a static enforcement mechanism that will guarantee that all classes fulfil their copy policy, even in the presence of overriding of copy methods, and establish the semantic correctness of the overall approach in Coq. The mechanism has been implemented and experimentally evaluated on clone methods from several Java libraries.

Testing coupling relationships in object‐oriented programs

AbstractAs we move toward developing object‐oriented (OO) programs, the complexity traditionally found in functions and procedures is moving to the connections among components. Different faults occur when components are integrated to form higher‐level structures that aggregate the behavior and state. Consequently, we need to place more effort on testing the connections among components. Although OO technologies provide abstraction mechanisms for building components that can then be integrated to form applications, it also adds new compositional relations that can contain faults. This paper describes techniques for analyzing and testing the polymorphic relationships that occur in OO software. The techniques adapt traditional data flow coverage criteria to consider definitions and uses among state variables of classes, particularly in the presence of inheritance, dynamic binding, and polymorphic overriding of state variables and methods. The application of these techniques can result in an increased ability to find faults and to create an overall higher quality software. Copyright © 2010 John Wiley &amp; Sons, Ltd.

Delegation by object composition

Class inheritance and method overriding, as provided by standard class-based languages, are often not flexible enough to represent objects with some dynamic behavior. In this respect, object composition equipped with different forms of method body lookup is often advocated as a more flexible alternative to class inheritance since it takes place at run time, thus permitting the behavior of objects to be specialized dynamically. In this paper, we illustrate Incomplete Featherweight Java (IFJ), an extension of Featherweight Java with a novel linguistic construct, the incomplete object. Incomplete objects require some missing methods which can be provided at run time by composition with another (complete) object. Furthermore, we present two mechanisms for the method body lookup on (composed) objects, one based on delegation and the other based on consultation. Thanks to the design of the language, the consultation-based lookup is a simple extension of the delegation-based one. Both mechanisms are disciplined by static typing, therefore the language enjoys type safety (which implies no “message-not-understood” run-time errors) and avoids possible accidental overrides due to method name clashes.

Enhancing modular OO verification with separation logic

Conventional specifications for object-oriented (OO) programs must adhere to behavioral subtyping in support of class inheritance and method overriding. However, this requirement inherently weakens the specifications of overridden methods in superclasses, leading to imprecision during program reasoning. To address this, we advocate a fresh approach to OO verification that focuses on the distinction and relation between specifications that cater to calls with static dispatching from those for calls with dynamic dispatching. We formulate a novel specification subsumption that can avoid code re-verification, where possible. Using a predicate mechanism, we propose a flexible scheme for supporting class invariant and lossless casting. Our aim is to lay the foundation for a practical verification system that is precise, concise and modular for sequential OO programs. We exploit the separation logic formalism to achieve this.

Modular typestate checking of aliased objects

Objects often define usage protocols that clients must follow inorder for these objects to work properly. Aliasing makes itnotoriously difficult to check whether clients and implementations are compliant with such protocols. Accordingly, existing approaches either operate globally or severely restrict aliasing. We have developed a sound modular protocol checking approach, based on typestates, that allows a great deal of flexibility in aliasing while guaranteeing the absence of protocol violations at runtime. The main technical contribution is a novel abstraction, access permissions , that combines typestate and object aliasing information. In our methodology, developers express their protocol design intent through annotations based on access permissions. Our checking approach then tracks permissions through method implementations. For each object reference the checker keeps track of the degree of possible aliasing and is appropriately conservativein reasoning about that reference. This helps developers account for object manipulations that may occur through aliases. The checking approach handles inheritance in a novel way, giving subclasses more flexibility in method overriding. Case studies on Java iterators and streams provide evidence that access permissions can model realistic protocols, and protocol checking based on access permissions can be used to reason precisely about the protocols that arise in practice.

Order of explanation should be interface

Most textbooks about object-oriented programming start explaining the OOP triumvirate, inheritance - abstract classes - interface , in this order. The article explains why the Design Patterns First methodology changes this order of explanation. It suggests explaining the interface at the beginning of course. After some experience it should follow by explaining abstract classes and inheritance without method overriding and after more experience by explaining inheritance of standard classes and method overriding.

Region inference for an object-oriented language

Region-based memory management offers several important potential advantages over garbage collection, including real-time performance, better data locality, and more efficient use of limited memory. Researchers have advocated the use of regions for functional, imperative, and object-oriented languages. Lexically scoped regions are now a core feature of the Real-Time Specification for Java (RTSJ)[5].Recent research in region-based programming for Java has focused on region checking, which requires manual effort to augment the program with region annotations. In this paper, we propose an automatic region inference system for a core subset of Java. To provide an inference method that is both precise and practical, we support classes and methods that are region-polymorphic, with region-polymorphic recursion for methods. One challenging aspect is to ensure region safety in the presence of features such as class subtyping, method overriding, and downcast operations. Our region inference rules can handle these object-oriented features safely without creating dangling references.

Efficient Execution of Pure Object-Oriented Programs by Follow-up Compilation

Dynamic type checking and method binding slows pure object-oriented programs such as those written in Smalltalk. Dynamic method lookup is needed to support method overriding and type-method conformance. We have developed a platform independent technique that implements method overriding efficiently for pure object-oriented languages. The technique involves binding non-overridden method calls at compile time. The overridden method calls are also resolved (and bound) statically using simple inferences. Overridden method bindings are corrected dynamically using an Overridden Method Dictionary. Using simulations, we demonstrate that this technique offers 35%-70% reduction in the average method lookup delay over the Berkeley Smalltalk implementation. This technique has very low compile time overhead, memory overhead, does not need specialized hardware and allows shared code pages in concurrent programs. For programs which may be re-used, it is proper to have a follow-up compilation to generate efficient code after the program development is complete.

Defeasible Inheritance Through Specialization

Typed substitution provides a means of capturing inheritance in logic deduction systems. However, in the presence of method overriding and multiple inheritance, inheritance is known to be nonmonotonic, and the semantics of programs becomes a problematic issue. This article attempts to provide a general framework, based on Dung's argumentation theoretic framework, for developing a natural semantics for programs with dynamic nonmonotonic inheritance. The relationship between the presented semantics and perfect‐model (with overriding) semantics, proposed by Dobbie and Topor (1995), is investigated. It is shown that for inheritance‐stratified programs, the two semantics coincide. However, the proposed semantics also provides correct skeptical meanings for the programs that are not inheritance‐stratified.

Computing change and specificity with equational logic programs

Recent deductive approaches to reasoning about action and chance allow us to model objects and methods in a deductive framework. In these approaches, inheritance of methods comes for free, whereas overriding of methods is unsupported. In this paper, we present an equational logic framework for objects, methods, inheritance and overriding of methods. Overriding is achieved via the concept of specificity, which states that more specific methods are preferred to less specific ones. Specificity is computed with the help of negation as failure. We specify equational logic programs and show that their completed versions behave as intended. Furthermore, we prove that SLDENF-resolution is complete if the equational theory is finitary, the completed programs are consistent and no derivation flounders or is infinite. Moreover, we give syntactic conditions which guarantee that no derivation flounders or is infinite. Finally, we discuss how the approach can be extended to reasoning about the past in the context of incompletely specified objects or situations. It will turn out that constructive negation is needed to solve these problems.

Toward Foundations of Concurrent Object‐Oriented Programming‐Types and Language Design

A number of attempts have been made to obtain type systems for object‐oriented programming. The view that lies common is “object‐oriented programming = λ‐calculus + record.” Based on an analogous view “concurrent object‐oriented programming = concurrent calculus + record,” we aim to establish a foundation for concurrent object‐oriented programming. We choose our own Higher‐Order ACL as a basic concurrent calculus, and show that a concurrent object‐oriented language can be easily encoded in the Higher‐Order ACL extended with record operations. Since Higher‐Order ACL has a strong type system with a polymorphic type Inference mechanism, programs of the concurrent object‐oriented language can be automatically type‐checked by the encoding in Higher‐Order ACL. Our approach can give clear accounts for various important mechanisms such as inheritance, method overriding and access control for methods within a simple framework.