Fabrizio Giudici's Blog

Community: NetBeans Archives

I must admit: Eclipse is the best tool in its class

Well, this is the sound opinion of a person who has been using it for years. There's no history: Eclipse is just the best tool of its class. I've tried some alternatives, but nothing allowed me to operate quickly and having such a clean result as Eclipse did. Just nothing. And if you're in pain, trying to deliver when operating in the field, maybe in a problematic environment, Eclipse just gets you out of your troubles in a few minutes.

Don't trust of what competitors say, it's marketing hype, Eclipse is just the best tool of its class.

Long life to Eclipse! :-)

Mailing list di NetBeans in Italiano

Well, as an exceptional case I'm going to blog here in italian. The point is that we have an italian mailing list for NetBeans, so it's a pretty local interest.

Dunque, o voi tutti utilizzatori italiani di NetBeans, abbiamo finalmente una mailing list in cui possiamo scriverci nella nostra lingua madre. Questo strumento mi è stato chiesto da alcuni di voi durante i NetBeans Days tenuti nello scorso Settembre a Roma, Milano e Cagliari e Sun Microsystems è stata molto gentile nel risponderci positivamente. Janice Campbell, responsabile del programma di localizzazione, ci ricorda che questa è l'ottava mailing list su NetBeans non in inglese.

L'indirizzo della mailing list è nbdiscuss_it@netbeans.org e per iscriversi basta mandare un messaggio vuoto a nbdiscuss_it-subscribe@netbeans.org. Gli archivi sono disponibili su http://www.netbeans.org/servlets/SummarizeList?listName=nbdiscuss_it

Ora, non ci resta che far partire un po' di discussioni interessanti!

Feedback from the IDE Day in Genoa

A quick feedback from the IDE Day in Genoa, waiting for the other IDE Day in Rome to be over before posting a final report. Well, the day in Genoa was a success: while I don't have gotten yet the official data, there should have been 130+ attendees, which is very good. The talks by our guests from IntelliJ, Oracle and Sun were of very high quality, as expected; and the large number of questions proved that they caught the attention of people. Congratulations to the JUG steering commitee for their first large event, even considering that they resumed the JUG almost from zero about one year ago.

In spite of being my home town, unfortunately I wasn't able to attend it because of an engagement in Milan; I only got in in the latest minutes of the panel session. But I fully enjoyed the final dinner based on genoese cuisine and fish... :-)

New improvements for building NetBeans RCP apps - and OpenBlueSky available

• lib/nbm - where you place the referenced platform packaged in form of nbm files;
• lib/nbm/NetBeans6.0RC1 - where you place the modules of the NetBeans Platform that you need to use;
• lib/platform7-base - where you place some files from the NetBeans platform that can't be packaged into a nbm file;
• src/ - your sources

• lib/platform - where you place the referenced platform packaged in form of nbm files

 <property name="platform.dir" value="lib/platform" />
 <property name="nbm.dir" value="lib/nbm" />
 
 ...

    <target name="generate-platform">
        <delete dir="${platform.dir}" failonerror="false" />
        <mkdir dir="${platform.dir}" />
        <copy todir="${platform.dir}/platform7">
            <fileset dir="lib/platform7-base" />
        </copy>
        <generatePlatform platformTargetFolder="${platform.dir}" >
            <fileset dir="${nbm.dir}"/>
            <fileset dir="${nbm.dir}/NetBeans6.0RC1"/>
        </generatePlatform>
    </target>

<project name="MyApplication" basedir="." default="build">
    <description>...</description>
    <property name="platform.dir" value="lib/platform" />
    <property name="nbm.dir" value="lib/nbm" />
    <property file="nbproject/platform.properties"/>
    <property file="nbproject/private/platform-private.properties"/>
    <propertyfile file="${user.properties.file}" comment="">
        <entry key="nbplatform.${nbplatform.active}.harness.dir" value="$${nbplatform.default.harness.dir}"/>
        <entry key="nbplatform.${nbplatform.active}.label" value="${nbplatform.active}"/>
        <entry key="nbplatform.${nbplatform.active}.netbeans.dest.dir" value="${basedir}/${platform.dir}"/>
    </propertyfile>
    <import file="nbproject/build-impl.xml"/>
...

NetBeans RCP - beyond suite chaining

• blueMarine Libraries. It's a "fake" component which only contains some module wrappers for a certain number of libraries required by the project(s) just for saving some compilation time.
• blueMarine Core. It's the basic imaging components of blueMarine. It can be used by developers for developing other imaging applications.
• blueMarine. It's the actual application.
• Generic Plugin. It's a generic plugin that people can develop for blueMarine.

• OpenBlueSky. It's a set of components that enhance the NetBeans RCP. It is a new spin off of blueMarine Core.
  
• ForceTen. It's a set of components for showing 2D and 3D maps. It is a new spin off of blueMarine.

Also consider that the previous diagram has been simplified: we should take into account that, for instance, there are multiple dependencies on JOGL (they are best shown in the next diagram).

1. Update NBMs in chain, which can't be just achieved by copying files, since e.g. a certain module could be deleted or renamed at a point; this means that the old file should be removed from dependent platforms as well.
2. Create / update the platforms with their clusters. NetBeans isn't able to directly compile against NBM files, which are just a convenient way to pack things. Instead, they are expanded following a well known file tree into a platform, which is the artifact NetBeans is able to compile against.
3. Last but not least, you might want to have platforms and NBM files checked into Subversion. This approach not only makes it easier to work on a single sub-project without downloading all the sources of ancestor projects, but also delivers reproducibility as each revision has a well established set of both sources and libraries. Not only you should use Subversion appropriately whenever a certain file has been added, modified or removed, but you have to cope with a subtle problem: since NBM files contain the compilation timestamp, if you rebuild them even with no change in the sources, you always create a file with some changed bits. This means that any time you recompile NBMs Subversion has to commit all of them. Not only this eats up a lot of space in the source repository, but makes it much harder to track changes by looking at the commit history.
   

1. sourceFolders, a colon-separated list of directories where there are some "source" NBMs to get.
2. nbmFolder, a single directory where the NBM files are copied. This directory is kept as a reference to understand which files have been changed since the last time. To solve the timestamp problem cited above, copyUpdatedStuff doesn't compare contents, but the embedded version tag from the manifest of each module.
   
3. platformFolders, a colon-separated list of directories where copyUpdatedStuff expands the NBM files to create clusters.
   

    <property name="source.nbm.path" value="${openbluesky.dir}/build/updates:
                                            ${bluemarine-libraries.dir}/build/updates:
                                            ${bluemarine-core.dir}/build/updates:
                                            ${jogl-libraries.dir}/build/updates:
                                            ${forceten.dir}/build/updates"/>

    <property name="nbm.dir" value="lib/nbm" />
    <property name="platform.dir" value="lib/platform"/>

    <property name="platform.path" value="${platform.dir}/openbluesky:
                                          ${platform.dir}/bluemarine_libraries: 
                                          ${platform.dir}/bluemarine_core:
                                          ${platform.dir}/jogl-libraries:
                                          ${platform.dir}/forceten"/>

    <target name="prepare-platform">
        <copyUpdatedStuff sourceFolders="${source.nbm.path}"
                          nbmFolder="${nbm.dir}"
                          platformFolders="${platform.path}"/>
    </target>

   ./nbm
   ./lib/platform/bluemarine_core/config/Modules
   ./lib/platform/bluemarine_core/config
   ./lib/platform/bluemarine_core/core/locale
   ./lib/platform/bluemarine_core/core
   ./lib/platform/bluemarine_core/modules/locale
   ./lib/platform/bluemarine_core/modules
   ./lib/platform/bluemarine_core/update_tracking
   ./lib/platform/bluemarine_core
   ./lib/platform/bluemarine_libraries/config/Modules
   ./lib/platform/bluemarine_libraries/config
   ./lib/platform/bluemarine_libraries/modules/ext
   ./lib/platform/bluemarine_libraries/modules
   ./lib/platform/bluemarine_libraries/update_tracking
   ./lib/platform/bluemarine_libraries
   ./lib/platform/forceten/config/Modules
   ./lib/platform/forceten/config
   ./lib/platform/forceten/modules/ext
   ./lib/platform/forceten/modules
   ./lib/platform/forceten/update_tracking
   ./lib/platform/forceten
   ./lib/platform/jogl-libraries/config/Modules
   ./lib/platform/jogl-libraries/config
   ./lib/platform/jogl-libraries/modules/ext
   ./lib/platform/jogl-libraries/modules/lib
   ./lib/platform/jogl-libraries/modules
   ./lib/platform/jogl-libraries/update_tracking
   ./lib/platform/jogl-libraries
   ./lib/platform/openbluesky/config/Modules
   ./lib/platform/openbluesky/config
   ./lib/platform/openbluesky/modules/ext
   ./lib/platform/openbluesky/modules/lib
   ./lib/platform/openbluesky/modules
   ./lib/platform/openbluesky/update_tracking
   ./lib/platform/openbluesky

   ./lib/platform/ide8/config/Modules
   ./lib/platform/ide8/config
   ./lib/platform/ide8/modules/ext
   ./lib/platform/ide8/modules/lib
   ./lib/platform/ide8/modules
   ./lib/platform/ide8/update_tracking
   ./lib/platform/platform7/config/ModuleAutoDeps
   ./lib/platform/platform7/config/Modules
   ./lib/platform/platform7/config
   ./lib/platform/platform7/core
   ./lib/platform/platform7/docs
   ./lib/platform/platform7/lib
   ./lib/platform/platform7/modules/ext
   ./lib/platform/platform7/modules
   ./lib/platform/platform7/update_tracking

prepare-platform:
[copyUpdatedStuff] 0 new module(s):      
[copyUpdatedStuff] 2 updated module(s):  it-tidalwave-bluemarine-calendarexplorer (2.2.10) in: bluemarine-core, it-tidalwave-geo-geoexplorer (1.0.6) in: ForceTen
[copyUpdatedStuff] 0 obsolete module(s): 
[copyUpdatedStuff] Copying and updating: it-tidalwave-bluemarine-calendarexplorer.nbm
[copyUpdatedStuff] Copying and updating: it-tidalwave-geo-geoexplorer.nbm
[copyUpdatedStuff] Copying and updating: config/Modules/it-tidalwave-bluemarine-calendarexplorer.xml
[copyUpdatedStuff] Copying and updating: modules/it-tidalwave-bluemarine-calendarexplorer.jar
[copyUpdatedStuff] Copying and updating: update_tracking/it-tidalwave-bluemarine-calendarexplorer.xml
[copyUpdatedStuff] Copying and updating: config/Modules/it-tidalwave-geo-geoexplorer.xml
[copyUpdatedStuff] Copying and updating: modules/it-tidalwave-geo-geoexplorer.jar
[copyUpdatedStuff] Copying and updating: update_tracking/it-tidalwave-geo-geoexplorer.xml

Work in progress: ForceTen

• integration with different map renderers: SwingLabs JXMapViewer, NASA World Wind (done), possibly a JavaScript-based renderer (for running the Google Maps APIs and showing Google Maps in a legal way (*)) and a SVG renderer (for SVG data published by OpenStreetMap);
• integration with different geo-coding providers;
• support for drag-and-drop geotagging;
  
• specific integration with NetBeans (even though I'll try to publish some stuff as plain J2SE).

Creative use of the NetBeans Visual Library: the Light Table

• Thumbnail is just a reduced size image used as a photo preview. It is smart enough to be asynchronous, that is it can be generated in background and fire events when data (raster and metadata) are available.
  
• ThumbnailManager is the manager for Thumbnails; you usually call it as
  

  DataObject dataObject = ...;
  Thumbnail thumbnail = thumbnailManager.findThumbnail(dataObject);
  

  Remember that DataObject is the standard way of representing a datum with NetBeans. Whenever you're dealing with a photo, the code above will give you a working thumbnail (or create one if it doesn't exist).
• ThumbnailRenderer is the renderer for thumbnails. It is able to deal with the asynchronous model of a Thumbnail, that is to quickly render a placeholder if the Thumbnail is not ready yet, and repaint it later when the image is available.
• ThumbnailTracker is a container of a set of Nodes which are capable of update themselves when the related Thumbnails are updated. The typical use is:
  
  Node node = thumbnailTracker.add(dataObject.getNodeDelegate());
  

• it defines the concept of "selected" widgets, as well as "hovering" widgets (i.e. the object under the mouse) and others; and fires the proper events to notify external listeners;
• it provides an association between a Widget and a custom object - that is, the model for your Widget.

    /** This object manages a set of thumbnailed nodes. */
    private final ThumbnailTracker thumbnailTracker = new ThumbnailTracker();
    
    /** The scene manager from Visual Library. */
    private final ObjectScene scene = new ObjectScene();
    
    /** The main layer where Widgets are added. */
    private final LayerWidget mainLayer = new LayerWidget(scene);

    private void internalAdd (final DataObject dataObject, final Point location)
      {
        final Node node = thumbnailTracker.add(dataObject.getNodeDelegate());
        final Thumbnail thumbnail = ThumbnailManager.Locator.findThumbnailManager().findThumbnail(dataObject);
        final ThumbnailWidget widget = new ThumbnailWidget(scene, thumbnail, node);

        // widget.setPreferredLocation(widget.convertLocalToScene(location));
        final Point sceneLocation = scene.convertViewToScene(viewLocation);
        final Point localLocation = mainLayer.convertSceneToLocal(sceneLocation);
        widget.setPreferredLocation (localLocation);

        mainLayer.addChild(widget);
        scene.addObject(dataObject, widget);
        widget.getActions().addAction(scene.createSelectAction());
        widget.getActions().addAction(scene.createObjectHoverAction());
        scene.validate(); // See first entry of http://graph.netbeans.org/faq.html
      }

    private void internalRemove (final DataObject dataObject)
      {
        scene.removeObject(dataObject);
        final List widgets = scene.findWidgets(dataObject);
        scene.removeObject(dataObject);

        for (final Widget widget : widgets) // removeObject() doesn't remove widgets
          {

            widget.removeFromParent();
          }
      }

• ThumbnailWidget is a specialized visual object that I'll describe below.
• A Scene can contain many layers (LayerWidget), that are the place where Widgets are placed. In the simplest cases, you just need one of them.
• Capabilities can be added to Widgets by adding WidgetActions to them. Most of WidgetActions can be created from an ActionFactory (see code sketches below), while some are provided by the ObjectScene (in the code, the action for managing the selection and the hovering status).
  

    /** The view component. */
    private final JComponent view = scene.createView();
    
    /** The view component. */
    private final JComponent satelliteView = scene.createSatelliteView();

    private final DropTarget dropTarget = new DropTarget()
      {
        @Override
        public void drop (final DropTargetDropEvent event) 
          {
            try
              {
                for (final DataFlavor flavor : event.getCurrentDataFlavors())
                  {
                    final Class<?> clazz = flavor.getRepresentationClass();

                    if (DataObject.class.isAssignableFrom(clazz))
                      {
                        final DataObject dataObject = (DataObject)event.getTransferable().getTransferData(flavor);
                        //
                        // This tests if the current DataObject has Thumbnail capability.
                        //
                        if (dataObject.getLookup().lookup(Thumbnail.DataProvider.class) != null)
                          {
                            event.acceptDrop(event.getDropAction());
                            internalAdd(dataObject, event.getLocation());
                            event.dropComplete(true);
                            return;
                          }
                      }
                  }
                
              }
            catch (Exception e)
              {
                logger.throwing(CLASS, "drop()", e);
              }

            event.dropComplete(false);
          }
      };

...
    view.setDropTarget(dropTarget);

public class ThumbnailWidget extends Widget
  {
    private static final ThumbnailRenderer thumbnailRenderer = new SimpleThumbnailRenderer();
    
    private final Thumbnail thumbnail;
    
    private final Node node;

    public ThumbnailWidget (final Scene scene, final Thumbnail thumbnail, final Node node)
      {
        super(scene);  
        this.thumbnail = thumbnail;
        this.node = node;
      }

    @Override
    protected void paintWidget()
      {
        final Graphics2D g = getGraphics();
        final AffineTransform transformSave = g.getTransform();
        final Rectangle bounds = getClientArea();
        thumbnailRenderer.setThumbnail(thumbnail);
        g.translate(bounds.x, bounds.y);
        thumbnailRenderer.setBounds(bounds);
        final double zoomFactor = getScene().getZoomFactor();
        g.scale(1 / zoomFactor, 1 / zoomFactor);
        thumbnailRenderer.paint(g);
        g.setTransform(transformSave);        
      }
  }

    private final NodeListener iconChangeListener = new NodeAdapter() 
      {
        @Override
        public void propertyChange (final PropertyChangeEvent event) 
          {
            if (Node.PROP_ICON.equals(event.getPropertyName()))
              {
                repaint(); 

                //
                // The Nodes API can fire events outside of the AWT Thread
                //
                if (SwingUtilities.isEventDispatchThread()) 
                  {
                    repaint();

                    getScene().validate();
                  }
                else
                  {
                    SwingUtilities.invokeLater(new Runnable() 
                  {
                    public void run() 
                      {
                        repaint();
                        getScene().validate();
                      }
                  });
                 }
              }
          }
      };

// in the constructor of ThumbnailWidget:
    node.addNodeListener(iconChangeListener); 

    private final PopupMenuProvider popupMenuProvider = new PopupMenuProvider() 
      {
        public JPopupMenu getPopupMenu (final Widget widget, final Point location) 
          {
            return node.getContextMenu();
          }
      }; 

// in the constructor of ThumbnailWidget:
        getActions().addAction(ActionFactory.createPopupMenuAction(popupMenuProvider));

    private class ActionFilterNode extends FilterNode
      {
        public ActionFilterNode (final Node node)
          {
            super(node);    
          }
        
        @Override
        public final Action[] getActions (final boolean context)
          {
            final List<Action> actions = new ArrayList<Action>(Arrays.asList(super.getActions(context)));
            
            for (int i = 0; i < actions.size(); i++)
              {
                final Action action = actions.get(i);
                
                if ((action != null) && AddToLightTableAction.class.equals(action.getClass()))
                  {
                    actions.set(i, SystemAction.get(RemoveFromLightTableAction.class));
                    break;
                  }
              }
                
            return actions.toArray(new Action[0]);
          }
      }

// in the constructor of ThumbnailWidget:
    this.node = new ActionFilterNode(node);

    private static final WidgetAction.Adapter bringToFrontAction = new WidgetAction.Adapter()
      {
        @Override
        public State mouseClicked (final Widget widget, final WidgetMouseEvent event) 
          {
            if (event.getButton() == MouseEvent.BUTTON1) 
              {
                widget.bringToFront();
                return State.CONSUMED;
              } 

            return State.REJECTED;
          }
      };

// in the constructor of ThumbnailWidget:
    getActions().addAction(bringToFrontAction);

        getActions().addAction(ActionFactory.createMoveAction());

        getActions().addAction( ActionFactory.createResizeAction());

        final WidgetAction resizeAction = ActionFactory.createResizeAction(resizeStrategy, 
                ActionFactory.createDefaultResizeProvider());
        getActions().addAction(resizeAction); // add this BEFORE createMoveAction()

    private final ResizeStrategy resizeStrategy = new ResizeStrategy() 
      {
        public Rectangle boundsSuggested (final Widget widget, 
                                          final Rectangle originalBounds, 
                                          final Rectangle suggestedBounds,
                                          final ResizeProvider.ControlPoint controlPoint)
          {
            final Rectangle result = new Rectangle(suggestedBounds);
            final double deltaW = Math.abs(suggestedBounds.getWidth() - originalBounds.getWidth());
            final double deltaH = Math.abs(suggestedBounds.getHeight() - originalBounds.getHeight());
            final Insets insets = getBorder().getInsets();
            final int mw = insets.left + insets.right;
            final int mh = insets.bottom + insets.top;
 
            if (deltaW >= deltaH) // moving mostly in horizontal
              {
                result.height = mh + Math.round((result.width - mw) * aspectRatio);
              }
            else // moving mostly in vertical
              {
                result.width = mw + Math.round((result.height - mh) / aspectRatio);
              }
            
            return result;
          }
      };

• by drawing a solid, white border around the selected widget;
• by drawing a "resize border", with the classic eight control point where you should drag the mouse, when the mouse is hovering on the Widget.

    @Override
    protected void notifyStateChanged (final ObjectState oldState, final ObjectState newState) 
      {
        super.notifyStateChanged(oldState, newState);
        setBorder(newState.isSelected() ? (newState.isHovered() ? RESIZE_SELECTED_BORDER : SELECTED_BORDER) :
                                          (newState.isHovered() ? RESIZE_BORDER : EMPTY_BORDER));
      }

Quick feedback from Jazoon

I still need some time to get to a comprehensive evaluation about Jazoon, so I will talk about the conference in general after the event is over. Nevertheless today I can say what has been the most interesting talk I've attended, since I think it will be highly unlikely that one of tomorrow's talks are better (also considering that I have to speak at two talks and I won't be able to attend other stuff in the same slots).

My favourite talk was Gregg Sporar's Integrated Profiling (with the NetBeans IDE). Well, I know the NetBeans Profiler quite well and I often use it, but Gregg illustrated some new trick that I wasn't aware of. I found it unbelievably useful: sure there are some debugging practices of mine that will be greatly improved by using all the potential of the tool. And also the Profiler in NetBeans 6 has some even new, great stuff (BTW, I've been using NetBeans 6 Milestones for months for a couple of projects, but never tried the profiler on them).

PS I've accomplished with large excess my goal of meeting more than twelve bloggers/VIP people; mostly thanks to the meeting of the JUG leaders. Also I'm so glad I've met Moritz Petersen. Moritz and I have been exchanging some emails about Java and imaging since a few months, and together with Emmanuele are planning to do something together...

My first NetBeans Day

And today I was finally able to attend my first NetBeans day, in Zurich!. Brian Leonard, Gregg Sporar, Roumen Strobl, Fabiola Rios gave the attendees an overview of the platform, both as IDE with the three Java editions (standard, enterprise, micro) and as Rich Client Platform API. Even though I use NetBeans a lot, I found the presentations really interesting (too bad there were no NetBeans Days in Italy...) and I also learnt something that I didn't knew. For instance, the new Profiler in 6.0 M9: it has been a great tool since some time already, but there's a new "Find GC path" feature, which tells you why a certain object has not been garbage collected yet (that is, which objects are still referencing it). It literally rocks for finding out memory leaks.

To me the day has been important for some reasons (in random order):

• I met Gregg and Brian (as well as Felipe Gaucho a.k.a. Felipe Silva) for the first time - I hope that at Jazoon, next week, I'll be able to meet at least a dozen people that I only talked by email or blog;
• believe it or not, I've seen my first sketch of Ruby on Rails code (never looked at a blog about it so far);
• it was my first public event as member of the Dream Team (unfortunately no other Dreamers were there, I hope for the next week);
• I gave a very quick introduction of blueMarine (waiting for the next week demos); with the exception of a meeting of the JUG Milan (but the project had just restarted its new NetBeans life), it's the first time it goes in a public meeting.

Last but not least, the weather in Zurich is variable, but the temperature is pleasant. A very good appetizer for Jazoon, next week. Now, my only problems are that I've to recover several hours of sleep (I've had some hard times last week) and I should get a better WiFi connection in my hotel (writing this blog entry has been a pain).

Below: Brian, Gregg, Roumen, Fabiola.

Feeling like the Buridan's Donkey

I don't know whether the expression "Buridan's Donkey" has the same meaning in english as in italian (I've just recenly discovered that the latin "qui(d) pro quo" has nowadays different meanings in english and romance languages). In any case, the history is about a donkey that starved and died since it had a lot of alternate foods to eat and it couldn't decide which was the most tasty to start eating with.

I feel in a similar way as I've found a lot of new Java toys to play with! :-)

• NASA World Wind - and Geertjan will soon tell us how to include it in NetBeans RPC apps
• With the latest NetBeans update I've found a Sun Grid plugin that allows to create and start jobs on the grid
• ... and I just discovered that now the Sun Grid is accessible from 24 countries other than USA, including Italy!!

Well, maybe the plugin was already there since some time, but I didn't notice it - knowing that the grid was not available for Italy it could not have attracted my attention. Now I've just subscribed to it, hopefully in a few days I'll have my account working. This is important, since the USA-only access really slowed down the development of the Grid plugin for Mistral. I can't promise anything... but maybe there will be something ready at the blueMarine / Mistral demo at Jazoon. ;-)

Wow Sun: I looooove you sooooooooo! ;-)

Automating test coverage reports with NetBeans and Cobertura

Whether you're an agilist or not, you should be aware that automated testing is one of the key factors for the success of your projects. While test runners such as JUnit are widely known, there are other powerful tools that can help: those that produce reports about your test coverage.

The count of tests for class, in fact, is not enough to understand whether your code is well covered; this depends on their structure and complexity. A basic rule says that tests should exercise every single line of your classes: but how can you check this in an easy way?

Tools such as Cobertura are useful in this scenario: by instrumenting the byte code of your classes, they can precisely report which percentage of your code is covered by test and even produce a pretty printed listing of your code where you can easily spot the uncovered parts in red (look here for an example).

Today coverage tools come also with plugins for the most popular IDE such as NetBeans, Eclipse or IDEA, so they can be launched with a button or a menu. I like this approach, but anyway I'm a fan of the old batch mode ;-) also because it can be easily integrated into a continuous integration server (in this way, automated testing and coverage report run without consuming computing resources on my laptop). So I want to have coverage tests both available in my NetBeans GUI and from the command line.

To make it possible is easy, thanks to the fact that Cobertura comes with a specific Ant target and the Ant scripts used by NetBeans can be customized.

Continue Reading...

Setting properties for JUnit testing and NetBeans

Keeping an old habit since the old times of C/C++ development and Makefile, mostly under Unix, I usually set environment variables to specify some properties that should be available during compiling or testing. But environment variables can create troubles sometimes.

For instance, Mistral automated tests need to deal with a number of images that are used as a test case. Unfortunately, most of these images are quite large (several megabytes) since they are digital photos (the main target of Mistral), often stored in a camera raw format (which Mistral can handle thank to jrawio). In the first distribution of Mistral just a couple of images were included, and this made the source zip 20mb large. Putting more images in the distribution is not a viable option - a best approach is to ask developers to download them optionally (after all many people who download sources could be not interested in running tests) - indeed the new JUnit tests are smart enough to automatically download the required images from the internet the first time they run.

Continue Reading...

God bless the tools that support well your process

Well, my last blog post was about the Rio plugin of Mistral, and ended with an open (and expected) problem related to performance - something that I thought I'd have addressed in the next post. But as often happens, other commitments prevented me from completing the next step in the planned time - I think we'll have to wait two or three weeks still.

In the meantime, I'm busy - among other things - with two small projects (to be precise, a tiny one and a small one, which anyhow is just the first phase of something that should evolve in future in a very interesting stuff). Both are related to imaging and both make use of Mistral, even though they just need its basic features. I'm taking the chance of another little diversion from my main blog topics and I'm going to talk about the process (you know, I'm a big fan of it, it's the process that saves a project rather than cool language syntax :-P ) and how a good tool should support it.

Continue Reading...

This work is licensed under a Creative Commons License.