Dealing with non-determinism in testing concurrent java components

The testing of concurrent software components can be difficult due to the inherent non-determinism present in these components. For example, if the same test case is run multiple times, it may produce different results. This non-determinism may lead to problems with determining expected outputs. In this paper, we present and discuss several possible solutions to this problem in the context of testing concurrent Java components using the ConAn testing tool. We then present a recent extension to the tool that provides a general solution to this problem that is sufficient to deal with the level of non-determinism that we have encountered in testing over 20 components with ConAn. © 2005 IEEE

Linguistic determinism and theory of mind in deaf children

DeVilliers and DeVilliers (2000, 2005) propose that deaf and hearing children acquire a theory of mind (or the understanding that human behaviour is the product of psychological states like true and false beliefs) as a consequence of their linguistic mastery of a rule of syntax. Specifically, they argue that the syntactic rule for sentential complementation with verbs of speech (e.g., “say”) precedes syntactic mastery of complementation for cognition (e.g., “think”) and both of these developmentally precede and promote conceptual mastery of a theory of mind (ToM), as indexed via success on standard false belief tests. The present study examined this proposition in groups of primary-school-aged deaf children and hearing preschoolers who took false belief tests and a modified memory for complements test that included control questions. Guttman scaling techniques indicated no support either for the prediction that syntactic skill precedes ToM understanding or for the earlier emergence of complementation for “say” than for “think”. Methodological issues and implications for deaf children's ToM development are discussed.

A classification of concurrency failures in java components

The Java programming language supports concurrency. Concurrent programs are hard to test due to their inherent non-determinism. This paper presents a classification of concurrency failures that is based on a model of Java concurrency. The model and failure classification is used to justify coverage of synchronization primitives of concurrent components. This is achieved by constructing concurrency flow graphs for each method call. A producer-consumer monitor is used to demonstrate how the approach can be used to measure coverage of concurrency primitives and thereby assist in determining test sequences for deterministic execution.