about me
my project

week one
week two
week three
week four & five
week six
week seven
week eight & nine
week ten
final report

random pictures
hiperspace people

the drive up
dave matthew's

Final Report

Project Summary
Last year Tiffany Wong, a 2000 CRA-DMP participant, began work on a JAVA tool, TATOO[2], to assist Amie Souter in collecting information about def-use pairs.

Last summer, various components of TATOO were implemented such as the graphical user interface and inclusion of the FLEX compiler infrastructure[4] and the daVinci toolkit[3]. My project was an extension of the TATOO tool. My project involved designing and implementing a trace analyzer in order to evaluate contextual def-use association (cdua)[1] coverage.

In order to get a better understanding of the concept of coverage analysis, I performed a web search for papers on the topic of coverage analysis. I focused on definitions, and mainly limited myself to the introduction, abstract, evaluation, and conclusion sections. The following is a brief list of papers and websites I studied:

  • S. Cornett. Code Coverage Analysis. http://www.bullseye.com
  • M.J. Harrold and G. Rothermel. Performing Data Flow Testing on Classes. In Proceedings of the Second ADMI SIGSOFT Symposium on the Foundations of Software Engineering, pages 154-163, December 1994.
  • E. V. Berard. Issues in the Testing og Object-Oriented Software. Berard Software Engineering. http://opax.swin.edu.au/303847/itd511/week3/oo_test.txt

  • After I became comfortable with the concept of coverage analysis, I began learning more about TATOO. I started by trying to run TATOO. One problem that slowed work this summer was lack of documentation for TATOO. Although some code was commented really well, in other places, there were no comments at all. Also, there was some confusion regarding what was actually implemented and what Lori and Amie thought was implemented. Most of their knowledge of the tool was from meetings they had attended over a year ago. I created a flow chart to show the relationship of Tiffany's classes, which is available here. Tiffany developed most of the framework for TATOO and began working on her idea of an analyzer. In her case, she would consider one test tuple and "highlight" portions of code that were covered during a single run with that test tuple. We wanted an analyzer that would allow the user to keep track of data for single runs or multiple runs. We also wanted the analyzer to use a "set" of test tuples (multiple tuples).

    My next step was to design the analyzer. We decided to add print statements to the code we were testing, which would print out pertinent information such as the definition line number, the use line number, and which test tuple the print statement was generated for. This way, if the line of code was "covered", we would get a print statement. All the print statements would print to a file, and then the analyzer would search through the file to find the def-use "paths". Lastly, the analyzer would report which paths were covered.

    Finally, I began implementing the analyzer. I did not finish implementation. I did learn Perl to write several scripts to format our test programs. The scripts included brackets.pl, which formated the test code and added brackets to conditional statements, and linenum.pl, which added line numbers to our test code for the print statements. Besides studying Perl, I also learned to read the "grammar" for Java.

    My next step in implementation was to program "Addprints.java", which added the print statements to the test code. During this time, I learned about Swing, as I had no previous experience with it. I also used Java to combine my work and TATOO by making more buttons and running the Perl scripts through Java commands.

    I drew a second flow chart to describe the interaction of files I developed while implementing my addition to TATOO. The flow chart is available here.

    My summer ended while I was trying to implement the last Perl script, analyze.pl. This is the script that parses the output file to determine which paths were covered.

    Where Do We Go From Here?
    Amie is working on finishing the tool this semester. Currently, she is finishing analyze.pl. The last steps in my project were testing the tool, documenting the tool, and gathering coverage statistics. Although I did leave lots of documentation (in hopes the next person wouldn't have such a large learning curve), there is still a need for documentation of the tool in its final state. Another problem we ran into during implementation was that the tool was written to test a single source file but many times in object-oriented programming, a program is compromised of many source files. The next person to take over this project will need to modify the tool to handle this. We discussed these modifications, and I believe they will be trivial. For instance, some modification to the print statements will need to be made so that we know which source file the line numbers pertain to.

    Conclusions and Thanks
    I had a wonderful summer at the University of Delaware. I met many wonderful people both in the lab and on campus. Everyone I talked to contributed in some way to my summer of learning. Thanks!

    This summer project was the first time I was in charge of my own project. I didn't have others working for me. This was mine. I learned a lot from my weekly meetings and the reports I gave.

    Special thanks to Lori, Amie, and Laura. The summer flew by.

    [1] A.L. Souter and L.L. Pollock. Contextual Def-Use Associations for Object Aggregation. ACM SIGPLAN-SIGSOFT Workshop on Program Analysis For Software Tools and Engineering (PASTE '01), June 2001.

    [2] A.L. Souter et. al. TATOO: Testing and Analysis Tool Object-Oriented Software. In Proceedings of the 7th International Conference, Tools and Algorithms for the Constructions and Analysis of Systems, held as part of ETAPS, April, 2001.

    [3] M. Frohlich and M. Werner. The Graph Visualization System daVinci. Technical report, Universitat Bremen, Germany, September 1994.

    [4] M. Rinard et. al. FLEX. www.flex-compiler.lcs.mit.edu, 2000.