<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.3.4">Jekyll</generator><link href="http://egonw.github.io/blog/feed/by_tag/junit.xml" rel="self" type="application/atom+xml" /><link href="http://egonw.github.io/blog/" rel="alternate" type="text/html" /><updated>2026-11-19T06:09:00+00:00</updated><id>http://egonw.github.io/blog/feed/by_tag/junit.xml</id><title type="html">chem-bla-ics</title><subtitle>Chemblaics (pronounced chem-bla-ics) is the science that uses open science and computers to solve problems in chemistry, biochemistry and related fields.</subtitle><author><name>Egon Willighagen</name></author><entry><title type="html">Multiple unit test inheritance with JExample</title><link href="http://egonw.github.io/blog/2010/10/26/multiple-unit-test-inheritance-with.html" rel="alternate" type="text/html" title="Multiple unit test inheritance with JExample" /><published>2010-10-26T00:10:00+00:00</published><updated>2010-10-26T00:10:00+00:00</updated><id>http://egonw.github.io/blog/2010/10/26/multiple-unit-test-inheritance-with</id><content type="html" xml:base="http://egonw.github.io/blog/2010/10/26/multiple-unit-test-inheritance-with.html"><![CDATA[<p>Two months ago I wrote about <a href="http://scg.unibe.ch/research/jexample">JExample</a> (see
<a href="https://chem-bla-ics.linkedchemistry.info/2010/08/14/specifying-unit-test-dependencies-with.html">Specifying unit test dependencies with JExample <i class="fa-solid fa-recycle fa-xs"></i></a>).
At the time, my examples did not include multiple unit test inheritance, but was informed later by @jexample
that is possible. I just got time to try it in the <a href="https://chem-bla-ics.linkedchemistry.info/2010/10/15/working-on-oscar-for-three-months.html">Oscar <i class="fa-solid fa-recycle fa-xs"></i></a>
project:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">@Test</span> <span class="kd">public</span> <span class="nc">Oscar</span> <span class="nf">testConstructor</span><span class="o">()</span>
<span class="kd">throws</span> <span class="nc">URISyntaxException</span>
<span class="o">{</span>
  <span class="nc">Oscar</span> <span class="n">oscar</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">Oscar</span><span class="o">();</span>
  <span class="nc">Assert</span><span class="o">.</span><span class="na">assertNotNull</span><span class="o">(</span><span class="n">oscar</span><span class="o">);</span>
  <span class="k">return</span> <span class="n">oscar</span><span class="o">;</span>
<span class="o">}</span>

<span class="nd">@Given</span><span class="o">(</span><span class="s">"#testConstructor"</span><span class="o">)</span>
<span class="kd">public</span> <span class="nc">String</span> <span class="nf">testNormalize</span><span class="o">(</span><span class="nc">Oscar</span> <span class="n">oscar</span><span class="o">)</span>
<span class="kd">throws</span> <span class="nc">URISyntaxException</span>
<span class="o">{</span>
  <span class="nc">String</span> <span class="n">input</span> <span class="o">=</span> <span class="n">oscar</span><span class="o">.</span><span class="na">normalize</span><span class="o">(</span>
    <span class="s">"This is a simple input string with benzene."</span>
  <span class="o">);</span>
  <span class="nc">Assert</span><span class="o">.</span><span class="na">assertNotNull</span><span class="o">(</span><span class="n">input</span><span class="o">);</span>
  <span class="k">return</span> <span class="n">input</span><span class="o">;</span>
<span class="o">}</span>

<span class="nd">@Given</span><span class="o">(</span><span class="s">"#testConstructor,#testNormalize"</span><span class="o">)</span>
<span class="kd">public</span> <span class="nc">List</span> <span class="nf">testTokenize</span><span class="o">(</span>
  <span class="nc">Oscar</span> <span class="n">oscar</span><span class="o">,</span> <span class="nc">String</span> <span class="n">input</span><span class="o">)</span> <span class="kd">throws</span> <span class="nc">Exception</span>
<span class="o">{</span>
  <span class="nc">List</span> <span class="n">tokens</span> <span class="o">=</span> <span class="n">oscar</span><span class="o">.</span><span class="na">tokenize</span><span class="o">(</span><span class="n">input</span><span class="o">);</span>
  <span class="nc">Assert</span><span class="o">.</span><span class="na">assertNotNull</span><span class="o">(</span><span class="n">tokens</span><span class="o">);</span>
  <span class="nc">Assert</span><span class="o">.</span><span class="na">assertNotSame</span><span class="o">(</span><span class="mi">0</span><span class="o">,</span> <span class="n">tokens</span><span class="o">.</span><span class="na">size</span><span class="o">());</span>
  <span class="k">return</span> <span class="n">tokens</span><span class="o">;</span>
<span class="o">}</span>

<span class="nd">@Given</span><span class="o">(</span><span class="s">"#testConstructor,#testTokenize"</span><span class="o">)</span>
<span class="kd">public</span> <span class="nc">List</span> <span class="nf">testRecognizeNamedEntities</span><span class="o">(</span>
  <span class="nc">Oscar</span> <span class="n">oscar</span><span class="o">,</span> <span class="nc">List</span> <span class="n">tokens</span><span class="o">)</span>
<span class="kd">throws</span> <span class="nc">Exception</span>
<span class="o">{</span>
  <span class="nc">List</span> <span class="n">entities</span> <span class="o">=</span>
    <span class="n">oscar</span><span class="o">.</span><span class="na">recognizeNamedEntities</span><span class="o">(</span><span class="n">tokens</span><span class="o">);</span>
  <span class="nc">Assert</span><span class="o">.</span><span class="na">assertNotNull</span><span class="o">(</span><span class="n">entities</span><span class="o">);</span>
  <span class="nc">Assert</span><span class="o">.</span><span class="na">assertEquals</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">entities</span><span class="o">.</span><span class="na">size</span><span class="o">());</span>
  <span class="k">return</span> <span class="n">entities</span><span class="o">;</span>
<span class="o">}</span>
</code></pre></div></div>

<p>The pattern here is that each test method returns one variable, so that any method depending on two
other unit test will have two parameters. The order is defined by the order in which they are given
by the <em>@Given</em> clause.</p>]]></content><author><name>Egon Willighagen</name></author><category term="java" /><category term="junit" /><summary type="html"><![CDATA[Two months ago I wrote about JExample (see Specifying unit test dependencies with JExample ). At the time, my examples did not include multiple unit test inheritance, but was informed later by @jexample that is possible. I just got time to try it in the Oscar project:]]></summary></entry><entry><title type="html">Specifying unit test dependencies with JExample</title><link href="http://egonw.github.io/blog/2010/08/14/specifying-unit-test-dependencies-with.html" rel="alternate" type="text/html" title="Specifying unit test dependencies with JExample" /><published>2010-08-14T00:10:00+00:00</published><updated>2010-08-14T00:10:00+00:00</updated><id>http://egonw.github.io/blog/2010/08/14/specifying-unit-test-dependencies-with</id><content type="html" xml:base="http://egonw.github.io/blog/2010/08/14/specifying-unit-test-dependencies-with.html"><![CDATA[<p>A while ago <a href="http://stackoverflow.com/questions/2584629/how-can-i-specifiy-junit-test-dependencies">I asked on StackOverflow</a> about options
to specify unit test dependencies. An example from the <a href="http://cdk.sf.net/">CDK</a> would be that aromaticity detection in some molecule would
require that all atom types are correctly perceived. I could test both in separate unit tests, but with <a href="http://www.junit.org/">JUnit</a> I
cannot have the aromaticity test ignored of the atom typing already failed. Now, being to specify such dependencies is useful, as the failing
aromaticity test may be caused by the faulty atom typing, but the failing aromaticity test seems to imply something is wrong with the
aromaticity detection algorithm.</p>

<p>One of the answers was <a href="http://scg.unibe.ch/research/jexample">JExample</a>. Consider this code:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">@RunWith</span><span class="o">(</span><span class="nc">JExample</span><span class="o">.</span><span class="na">class</span><span class="o">)</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">MoleculeTest</span> <span class="o">{</span>

  <span class="nd">@Test</span>
  <span class="kd">public</span> <span class="nc">MoleculeFactory</span> <span class="nf">testNewMoleculeFactory</span><span class="o">()</span> <span class="o">{</span>
    <span class="nc">Assert</span><span class="o">.</span><span class="na">fail</span><span class="o">(</span><span class="s">"too bad"</span><span class="o">);</span>
    <span class="k">return</span> <span class="k">new</span> <span class="nf">MoleculeFactory</span><span class="o">();</span>
  <span class="o">}</span>

  <span class="nd">@Given</span><span class="o">(</span><span class="s">"#testNewMoleculeFactory()"</span><span class="o">)</span>
  <span class="kd">public</span> <span class="nc">IMolecule</span> <span class="nf">testNewMolecule</span><span class="o">(</span><span class="nc">MoleculeFactory</span> <span class="n">factory</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">Assert</span><span class="o">.</span><span class="na">fail</span><span class="o">(</span><span class="s">"too bad"</span><span class="o">);</span>
    <span class="k">return</span> <span class="n">factory</span><span class="o">.</span><span class="na">getImmutable</span><span class="o">();</span>
  <span class="o">}</span>

<span class="o">}</span>
</code></pre></div></div>

<p>Reading this Java code requires some experience with JUnit4, but those who already know JUnit4 will also see that the code is somewhat
unusual. For of all, we define a special class to run the tests with: <em>JExample.class</em>. A second thing to note is that the top test method
actually returns something. The bottom test method is also differnt: instead of being annotated with <em>@Test</em>, it is annotated with
<em>@Given</em>. This latter annotation is introduced by JExample to define the dependencies between the tests. The parameter of this annotation
defines which test method it depends on. Moreover, it is now also clear what happens with the return value of the top test method: it is
passed as argument to the second test method.</p>

<p>Just to show that the system actually works, you can find a screenshot of the <a href="http://www.eclipse.org/">Eclipse</a> JUnit View
(the JExample update site did not work with Eclipse 3.6, so I have the JExample jar defined as build dependency in the project instead):</p>

<p><img src="/blog/assets/images/jexample.png" alt="" /></p>

<p>Clearly, only one test failed, while the <em>testNewMolecule()</em> method was ignored.</p>

<p>Now, I was wondering if the first method could be reused, and if so, if it would construct a new object. And it does, as is clear from the output of this code:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="nd">@Test</span>
  <span class="kd">public</span> <span class="nc">MoleculeFactory</span> <span class="nf">testNewMoleculeFactory</span><span class="o">()</span> <span class="o">{</span>
    <span class="k">return</span> <span class="k">new</span> <span class="nf">MoleculeFactory</span><span class="o">();</span>
  <span class="o">}</span>

  <span class="nd">@Given</span><span class="o">(</span><span class="s">"#testNewMoleculeFactory()"</span><span class="o">)</span>
  <span class="kd">public</span> <span class="nc">IMolecule</span> <span class="nf">testNewMolecule</span><span class="o">(</span><span class="nc">MoleculeFactory</span> <span class="n">factory</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Factory1: "</span> <span class="o">+</span> <span class="n">factory</span><span class="o">);</span>
    <span class="k">return</span> <span class="n">factory</span><span class="o">.</span><span class="na">getImmutable</span><span class="o">();</span>
  <span class="o">}</span>

  <span class="nd">@Given</span><span class="o">(</span><span class="s">"#testNewMoleculeFactory()"</span><span class="o">)</span>
  <span class="kd">public</span> <span class="nc">IMolecule</span> <span class="nf">testNewMolecule2</span><span class="o">(</span><span class="nc">MoleculeFactory</span> <span class="n">factory</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">"Factory2: "</span> <span class="o">+</span> <span class="n">factory</span><span class="o">);</span>
    <span class="k">return</span> <span class="n">factory</span><span class="o">.</span><span class="na">getImmutable</span><span class="o">();</span>
  <span class="o">}</span>
</code></pre></div></div>

<p>which outputs:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Factory2: com.github.egonw.odk.model.MoleculeFactory@7bd63e39
Factory1: com.github.egonw.odk.model.MoleculeFactory@42b988a6
</code></pre></div></div>

<p>This seems pretty useful. I am not sure yet if it solves all my dependency requirements, though. For example, what I really like to do, is link more complex tests to more than one more simpler tests, where it is clear that the complexer test will fail if one or more of the simpler tests fail. However, the JExample examples suggest that I can only define one dependency, whereas, for example, aromaticity detection depends on correct atom type perception, but also on ring detection. For now, this is a welcome extension of JUnit.</p>]]></content><author><name>Egon Willighagen</name></author><category term="java" /><category term="junit" /><category term="justdoi:10.1007/978-3-540-68255-4_8" /><summary type="html"><![CDATA[A while ago I asked on StackOverflow about options to specify unit test dependencies. An example from the CDK would be that aromaticity detection in some molecule would require that all atom types are correctly perceived. I could test both in separate unit tests, but with JUnit I cannot have the aromaticity test ignored of the atom typing already failed. Now, being to specify such dependencies is useful, as the failing aromaticity test may be caused by the faulty atom typing, but the failing aromaticity test seems to imply something is wrong with the aromaticity detection algorithm.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://egonw.github.io/blog/blog/assets/images/jexample.png" /><media:content medium="image" url="http://egonw.github.io/blog/blog/assets/images/jexample.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Extension point for running JUnit tests in a RCP Application instance?</title><link href="http://egonw.github.io/blog/2009/09/23/extension-point-for-running-junit-tests.html" rel="alternate" type="text/html" title="Extension point for running JUnit tests in a RCP Application instance?" /><published>2009-09-23T00:00:00+00:00</published><updated>2009-09-23T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2009/09/23/extension-point-for-running-junit-tests</id><content type="html" xml:base="http://egonw.github.io/blog/2009/09/23/extension-point-for-running-junit-tests.html"><![CDATA[<p>One thing that has been on my wishlist is to be able to run the unit tests we have for <a href="http://www.bioclipse.net/">Bioclipse</a> from inside a
running Bioclipse instance. That is, we have a Bioclipse Test Suite features on the update site, matching the functional features we have
there. Each such test suite would run all <a href="http://www.junit.org/">JUnit</a> tests we have for that feature.</p>

<p>The good thing about this is twofold:</p>

<ol>
  <li>users can verify that their installation is working as intended</li>
  <li>the development team can easily run the test suite on foreign systems, without the need to install a fully operational <a href="http://www.eclipse.org/">Eclipse</a> with Bioclipse development workspace</li>
</ol>

<p>Now, the tricky thing is likely the following. How do we get to run all test suites? That is, I don’t want to need to have to run the suites
for each feature separately. Of course, this is exactly what <a href="http://www.vogella.de/articles/EclipseExtensionPoint/article.html">extension points</a>
are for.</p>

<p>So, my question is, did anyone set up an system like this? And, is there an extension point that allows features to plugin additional
JUnit test suites into a larger test suite dynamically?</p>]]></content><author><name>Egon Willighagen</name></author><category term="eclipse" /><category term="bioclipse" /><category term="junit" /><summary type="html"><![CDATA[One thing that has been on my wishlist is to be able to run the unit tests we have for Bioclipse from inside a running Bioclipse instance. That is, we have a Bioclipse Test Suite features on the update site, matching the functional features we have there. Each such test suite would run all JUnit tests we have for that feature.]]></summary></entry><entry><title type="html">State of CDK 1.2.0…</title><link href="http://egonw.github.io/blog/2008/12/26/state-of-cdk-120.html" rel="alternate" type="text/html" title="State of CDK 1.2.0…" /><published>2008-12-26T00:00:00+00:00</published><updated>2008-12-26T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2008/12/26/state-of-cdk-120</id><content type="html" xml:base="http://egonw.github.io/blog/2008/12/26/state-of-cdk-120.html"><![CDATA[<p>The reason why I have not blogged in more than two weeks, was that I was hoping to blog about the CDK 1.2.0 release. This was originally aimed at
September, slipped into October, November and then December. There were only three show stoppers (see <a href="https://apps.sourceforge.net/mediawiki/cdk/index.php?title=CDK_1.2_TODO">this wiki page</a>),
one of which the <a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/api/org/openscience/cdk/interfaces/IChemObject.html">IChemObject</a>
interfaces were not properly tested.</p>

<p>The problem was that the unit tests for the methods in superinterfaces were not applied to implementations of subinterfaces.
For example, the unit test for <code class="language-plaintext highlighter-rouge">IElement.getSymbol()</code> was not applied to the class <code class="language-plaintext highlighter-rouge">Atom</code>, which implements <code class="language-plaintext highlighter-rouge">IAtom</code> which
is a subinterfaces of <code class="language-plaintext highlighter-rouge">IElement</code>.</p>

<p>In fixing this, I had to take some hurdles. For example: the unit test classes used a set up following the implementations; CDK 1.2.x has three
implementations of the interfaces: data, datadebug and nonotify. The last does not send around update notifications, and rough tests indicate it
is about 10% faster. The second implementation sends messages to the debugger for every modification of the data classes, which is, clearly,
useful for debugging purposes.</p>

<p>However, the JUnit4 test classes were basically doing the same. The unit test <code class="language-plaintext highlighter-rouge">DebugAtomTest</code> inherited form <code class="language-plaintext highlighter-rouge">AtomTest</code>, and only overwrote
customizations. <code class="language-plaintext highlighter-rouge">AtomTest</code>, itself, inherited from <code class="language-plaintext highlighter-rouge">ElementTest</code>. That’s where things got broken. In the single implementation set up, this
would have been fine, but to allow testing of all three implementations, <code class="language-plaintext highlighter-rouge">getBuilder()</code> had to be used.</p>

<p>And when I implemented that, I did not realize that <code class="language-plaintext highlighter-rouge">ElementTest</code> would do a test like:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">IElement</span> <span class="n">element</span> <span class="o">=</span> <span class="n">builder</span><span class="o">.</span><span class="na">newElement</span><span class="o">();</span>
<span class="c1">// test IElement functionality</span>
</code></pre></div></div>

<p>However, while the use of builder ensure testing of all three implementations, it does <strong>not</strong> run these tests on <code class="language-plaintext highlighter-rouge">IAtom</code> implementations.</p>

<p>The followed a long series of patches to get this fixed. One major first patch, was to define unit test frameworks like <code class="language-plaintext highlighter-rouge">AbstractElementTest</code>
which formalized running unit tests on any implementation, as I noticed that quite a few tests were still testing one particular implementation.
This allowed <code class="language-plaintext highlighter-rouge">DebugElementTest</code> to extend <code class="language-plaintext highlighter-rouge">AbstractElementTest</code>, instead of <code class="language-plaintext highlighter-rouge">ElementTest</code>, which would now extend <code class="language-plaintext highlighter-rouge">AbstractElementTest</code> too.</p>

<p>OK, with that out of the way, it was time to fix running the unit test for <code class="language-plaintext highlighter-rouge">IElement.getSymbol()</code> on <code class="language-plaintext highlighter-rouge">IAtom.getSymbol()</code>, which required the
removal of the use of <code class="language-plaintext highlighter-rouge">IChemObjectBuilder</code> implementations. So, I introduced <code class="language-plaintext highlighter-rouge">newChemObject()</code> which would return a fresh instance of the
actually tested implementation. That is, <code class="language-plaintext highlighter-rouge">DebugAtomTest</code> would return a new <code class="language-plaintext highlighter-rouge">DebugAtom</code>, and the <code class="language-plaintext highlighter-rouge">getSymbol()</code> test would now run on
<code class="language-plaintext highlighter-rouge">DebugAtom</code> and not <code class="language-plaintext highlighter-rouge">DebugElement</code>. Good.</p>

<p>No, not good. The actual implementation I was using, looks like:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">class</span> <span class="nc">DebugElementTest</span> <span class="n">extend</span> <span class="nc">AbstractElementTest</span> <span class="o">{</span>
  <span class="nd">@BeforeClass</span> <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">setup</span><span class="o">()</span> <span class="o">{</span>
    <span class="n">setChemObject</span><span class="o">(</span><span class="k">new</span> <span class="nc">DebugElement</span><span class="o">());</span>
  <span class="o">}</span>
<span class="o">}</span>

<span class="kd">public</span> <span class="kd">abstract</span> <span class="kd">class</span> <span class="nc">AbstractElementTest</span> <span class="n">extend</span> <span class="nc">AbstractChemObjectTest</span> <span class="o">{</span>
  <span class="nd">@Test</span> <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testGetSymbol</span><span class="o">()</span> <span class="o">{</span>
    <span class="nc">IElement</span> <span class="n">element</span> <span class="o">=</span> <span class="o">(</span><span class="nc">IElement</span><span class="o">)</span><span class="n">newChemObject</span><span class="o">();</span>
    <span class="c1">// do testing</span>
  <span class="o">}</span>
<span class="o">}</span>

<span class="kd">public</span> <span class="kd">abstract</span> <span class="kd">class</span> <span class="nc">AbstractChemObjectTest</span> <span class="o">{</span>
  <span class="kd">private</span> <span class="nc">IChemObject</span> <span class="n">testedObject</span><span class="o">;</span>
  <span class="kd">public</span> <span class="kd">static</span> <span class="nf">setChemObject</span><span class="o">(</span><span class="nc">IChemObject</span> <span class="n">object</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">this</span><span class="o">.</span><span class="na">testedObject</span> <span class="o">=</span> <span class="n">object</span><span class="o">;</span>
  <span class="o">}</span>
  <span class="kd">public</span> <span class="nc">IChemObject</span> <span class="nf">setChemObject</span><span class="o">(</span><span class="nc">IChemObject</span> <span class="n">object</span><span class="o">)</span> <span class="o">{</span>
    <span class="k">return</span> <span class="o">(</span><span class="nc">IChemObject</span><span class="o">)</span><span class="n">testedObject</span><span class="o">.</span><span class="na">clone</span><span class="o">();</span>
  <span class="o">}</span> <span class="c1">// just imagine it has try/catch here too</span>

  <span class="c1">// and here the tests for the IChemObject API</span>
  <span class="nd">@Test</span> <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testGetProperties</span><span class="o">()</span> <span class="o">{</span>
    <span class="nc">IChemObject</span> <span class="n">element</span> <span class="o">=</span> <span class="o">(</span><span class="nc">IChemObject</span><span class="o">)</span><span class="n">newChemObject</span><span class="o">();</span>
    <span class="c1">// do testing</span>
  <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>

<p>Excellent! No.</p>

<p>Well, yes. The above system works, but made many unit tests fail, because of bugs in <code class="language-plaintext highlighter-rouge">clone()</code> methods. The full scope has to be explored,
but at least <code class="language-plaintext highlighter-rouge">IPolymer.clone()</code> is not doing what I would expect it to do. Either I am wrong, and need to overwrite the clone unit tests
of superinterfaces in <code class="language-plaintext highlighter-rouge">AbstractPolymerTest</code>, or the implementations needs fixing. I emailed the cdk-devel mailing list and filed a bug
report. But having about 1000 unit tests fail, because of clone broken, is something I did not like. For example, as it makes bug fixing
more difficult.</p>

<p>So, next step was to find an approach that did not require clone, but give some interesting insights in the Java language. JUnit4 requires
the <code class="language-plaintext highlighter-rouge">@BeforeClass</code> method to be static. This means I cannot have a non-static <code class="language-plaintext highlighter-rouge">DebugElementTest</code> method return an instance. And, you
cannot overwrite a static method! That had never occured to me in the past. <code class="language-plaintext highlighter-rouge">DebugElementTest.newChemObject()</code> does not overwrite
<code class="language-plaintext highlighter-rouge">AbstractChemObjectTest.newChemObject</code> which is somewhere upstream.</p>

<p>But, after discussing matters with Carl, I ended up with this approach:</p>

<div class="language-java highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">public</span> <span class="kd">abstract</span> <span class="kd">class</span> <span class="nc">AbstractChemObjectTest</span> <span class="kd">extends</span> <span class="nc">CDKTestCase</span> <span class="o">{</span>
  <span class="kd">private</span> <span class="kd">static</span> <span class="nc">ITestObjectBuilder</span> <span class="n">builder</span><span class="o">;</span>
  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">setTestObjectBuilder</span><span class="o">(</span><span class="nc">ITestObjectBuilder</span> <span class="n">builder</span><span class="o">)</span> <span class="o">{</span>
    <span class="nc">AbstractChemObjectTest</span><span class="o">.</span><span class="na">builder</span> <span class="o">=</span> <span class="n">builder</span><span class="o">;</span>
  <span class="o">}</span>
  <span class="kd">public</span> <span class="kd">static</span> <span class="nc">IChemObject</span> <span class="nf">newChemObject</span><span class="o">()</span> <span class="o">{</span>
    <span class="k">return</span> <span class="nc">AbstractChemObjectTest</span><span class="o">.</span><span class="na">builder</span><span class="o">.</span><span class="na">newTestObject</span><span class="o">();</span>
  <span class="o">}</span>
<span class="o">}</span>

<span class="kd">public</span> <span class="kd">interface</span> <span class="nc">ITestObjectBuilder</span> <span class="o">{</span>
  <span class="kd">public</span> <span class="nc">IChemObject</span> <span class="nf">newTestObject</span><span class="o">();</span>
<span class="o">}</span>

<span class="kd">public</span> <span class="kd">class</span> <span class="nc">DebugAtomTest</span> <span class="kd">extends</span> <span class="nc">AbstractAtomTest</span> <span class="o">{</span>
  <span class="nd">@BeforeClass</span> <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="o">{</span>
    <span class="n">setTestObjectBuilder</span><span class="o">(</span><span class="k">new</span> <span class="nc">ITestObjectBuilder</span><span class="o">()</span> <span class="o">{</span>
      <span class="kd">public</span> <span class="nc">IChemObject</span> <span class="nf">newTestObject</span><span class="o">()</span> <span class="o">{</span>
        <span class="k">return</span> <span class="k">new</span> <span class="nf">DebugAtom</span><span class="o">();</span>
      <span class="o">}</span>
    <span class="o">});</span>
  <span class="o">}</span>
<span class="o">}</span>
</code></pre></div></div>]]></content><author><name>Egon Willighagen</name></author><category term="cdk" /><category term="junit" /><category term="java" /><summary type="html"><![CDATA[The reason why I have not blogged in more than two weeks, was that I was hoping to blog about the CDK 1.2.0 release. This was originally aimed at September, slipped into October, November and then December. There were only three show stoppers (see this wiki page), one of which the IChemObject interfaces were not properly tested.]]></summary></entry><entry><title type="html">Comparing JUnit test results between CDK trunk/ and a branch #2</title><link href="http://egonw.github.io/blog/2008/05/02/comparing-junit-test-results-between.html" rel="alternate" type="text/html" title="Comparing JUnit test results between CDK trunk/ and a branch #2" /><published>2008-05-02T00:00:00+00:00</published><updated>2008-05-02T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2008/05/02/comparing-junit-test-results-between</id><content type="html" xml:base="http://egonw.github.io/blog/2008/05/02/comparing-junit-test-results-between.html"><![CDATA[<p>I reported earlier on how to compare unit test results <a href="http://chem-bla-ics.blogspot.com/2007/11/comparing-junit-test-results-between.html">between CDK trunk and a branch</a>.
Later, I noted that the diff typically overestimates the fail count, when unit tests had been moved to a different module. Therefore, a sort has
to be added. The code is also updated for the SVN directory restructuring:</p>

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>cdk cdk/
<span class="nv">$ </span>cdk trunk/
<span class="nv">$ </span>ant <span class="nt">-lib</span> develjar/junit-4.3.1.jar <span class="nt">-logfile</span> ant.log test-all
<span class="nv">$ </span><span class="nb">cd</span> ../branches/miguelrojasch-CMLReact
<span class="nv">$ </span>ant <span class="nt">-lib</span> develjar/junit-4.3.1.jar <span class="nt">-logfile</span> ant.log test-all
<span class="nv">$ </span><span class="nb">cd</span> ..
<span class="nv">$ </span><span class="nb">grep </span>Testcase trunk/reports/<span class="k">*</span>.txt | <span class="nb">cut</span> <span class="nt">-d</span><span class="s1">':'</span> <span class="nt">-f2</span>,3 | <span class="nb">sort</span> <span class="o">&gt;</span> trunk.results
<span class="nv">$ </span><span class="nb">grep </span>Testcase branches/miguelrojasch-CMLReact/reports/<span class="k">*</span>.txt | <span class="nb">cut</span> <span class="nt">-d</span><span class="s1">':'</span> <span class="nt">-f2</span>,3 | <span class="nb">sort</span> <span class="o">&gt;</span> branch.results
<span class="nv">$ </span>diff <span class="nt">-u</span> trunk.results branch.results
</code></pre></div></div>

<p>Obviously, you can still use wc for counting changes:</p>

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>diff <span class="nt">-u</span> trunk.results branch.results | <span class="nb">grep</span> <span class="s2">"^-Testcase"</span> | <span class="nb">wc</span> <span class="nt">-l</span>
<span class="nv">$ </span>diff <span class="nt">-u</span> trunk.results branch.results | <span class="nb">grep</span> <span class="s2">"^+Testcase"</span> | <span class="nb">wc</span> <span class="nt">-l</span>
</code></pre></div></div>

<p>A second improvement, would be taking advantage of the ant.log files that are created anyway. Using the
<a href="http://www.beanshell.org/">BeanShell</a> tool <a href="http://cdk.svn.sourceforge.net/viewvc/cdk/cdk/trunk/tools/extractTestStats.bsh?revision=10760&amp;view=markup">tools/extractTestStats.bsh</a>
revision 10760 (see also <a href="http://chem-bla-ics.blogspot.com/2008/02/cdk-is-now-available-from-your-nearest.html">this blog on bsh</a>):</p>

<div class="language-shell highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">$ </span>bsh trunk/tools/extractTestStats.bsh trunk/ant.log | <span class="nb">grep </span>run | <span class="nb">grep</span> <span class="nt">-v</span> total | <span class="nb">grep</span> <span class="nt">-v</span> antlogFile | <span class="nb">cut</span> <span class="nt">-d</span><span class="s1">' '</span> <span class="nt">-f1-4</span> | <span class="nb">sort</span> <span class="o">&gt;</span> trunk.overview
<span class="nv">$ </span>bsh trunk/tools/extractTestStats.bsh branches/miguelrojasch-CMLReact/ant.log | <span class="nb">grep </span>run | <span class="nb">grep</span> <span class="nt">-v</span> total | <span class="nb">grep</span> <span class="nt">-v</span> antlogFile | <span class="nb">cut</span> <span class="nt">-d</span><span class="s1">' '</span> <span class="nt">-f1-4</span> | <span class="nb">sort</span> <span class="o">&gt;</span> branch.overview
<span class="nv">$ </span>diff <span class="nt">-u</span> trunk.overview branch.overview
</code></pre></div></div>]]></content><author><name>Egon Willighagen</name></author><category term="cdk" /><category term="junit" /><summary type="html"><![CDATA[I reported earlier on how to compare unit test results between CDK trunk and a branch. Later, I noted that the diff typically overestimates the fail count, when unit tests had been moved to a different module. Therefore, a sort has to be added. The code is also updated for the SVN directory restructuring:]]></summary></entry><entry><title type="html">Comparing JUnit test results between CDK trunk/ and a branch</title><link href="http://egonw.github.io/blog/2007/11/07/comparing-junit-test-results-between.html" rel="alternate" type="text/html" title="Comparing JUnit test results between CDK trunk/ and a branch" /><published>2007-11-07T00:00:00+00:00</published><updated>2007-11-07T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2007/11/07/comparing-junit-test-results-between</id><content type="html" xml:base="http://egonw.github.io/blog/2007/11/07/comparing-junit-test-results-between.html"><![CDATA[<p>I have started using branches for non-trivial patches, like removing the HückelAromaticityDetector, in favor of the
<a href="http://chem-bla-ics.blogspot.com/2007/11/evidence-of-aromaticity.html">new CDKHückelAromaticityDetector</a>. I am doing
this in my personal <a href="http://cdk.svn.sf.net/svnroot/cdk/branches/egonw/remove-non-cdkatomtype-code/">remove-non-cdkatomtype-code</a>
branch, where I can quietly work on the patch until I am happy about it. I make sure to keep it synchronized with
trunk with regular <code class="language-plaintext highlighter-rouge">svn merge</code> commands.</p>

<p>Now, the goal is that my branch only fixed failing JUnit tests, not that it creates new regressions. To compare the
results between two versions of the <a href="">CDK</a>, I use these commands:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>$ cd cdk/trunk/cdk
$ ant -lib develjar/junit-4.3.1.jar -logfile ant.log test-all
$ cd ../../branches/egonw/remove-non-cdkatomtype-code/
$ ant -lib develjar/junit-4.3.1.jar -logfile ant.log test-all
$ cd ../../..
$ grep Testcase branches/egonw/remove-non-cdkatomtype-code/reports/*.txt | cut -d':' -f2,3 &gt; branch.results
$ grep Testcase trunk/cdk/reports/*.txt | cut -d':' -f2,3 &gt; trunk.results
$ diff -u trunk.results branch.results
</code></pre></div></div>

<p>The last diff commands gives me a quick overview of what has changed. See get the statistics, I can do:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>$ diff -u trunk.results branch.results | grep "^-Testcase" | wc -l
$ diff -u trunk.results branch.results | grep "^+Testcase" | wc -l
</code></pre></div></div>

<p>The first gives me the number of JUnit tests which are now no longer failing, while the second
gives me the number of tests which are new fails. Ideally, the second is zero. Unfortunately, not yet the case :)</p>]]></content><author><name>Egon Willighagen</name></author><category term="cdk" /><category term="junit" /><summary type="html"><![CDATA[I have started using branches for non-trivial patches, like removing the HückelAromaticityDetector, in favor of the new CDKHückelAromaticityDetector. I am doing this in my personal remove-non-cdkatomtype-code branch, where I can quietly work on the patch until I am happy about it. I make sure to keep it synchronized with trunk with regular svn merge commands.]]></summary></entry><entry><title type="html">CDK 1.0: a milestone after 7 year of development</title><link href="http://egonw.github.io/blog/2007/04/23/cdk-10-milestone-after-7-year-of.html" rel="alternate" type="text/html" title="CDK 1.0: a milestone after 7 year of development" /><published>2007-04-23T00:00:00+00:00</published><updated>2007-04-23T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2007/04/23/cdk-10-milestone-after-7-year-of</id><content type="html" xml:base="http://egonw.github.io/blog/2007/04/23/cdk-10-milestone-after-7-year-of.html"><![CDATA[<p>Last night, I <a href="http://sourceforge.net/project/showfiles.php?group_id=20024">released CDK 1.0</a> as the previous release candidate
did not show up new major problems. It is far from a perfect release (see these still <a href="http://wiki.cubic.uni-koeln.de/cdkwiki/doku.php?id=cdk1.0">TODO</a>’s
and <a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/">Nightly</a>, run by
<a href="http://cheminfoclub.blogspot.com/">Rajarshi</a>), but the core is pretty solid.</p>

<p>I would warmly thank everyone who has contributed to the project in one way or another (I worked more on maintainance than
implementing functionality), as it has been a great pleasure to make CDK releases. <a href="http://www.ohloh.net/">OHLOH</a> runs a rather nice
developer <a href="http://www.ohloh.net/projects/380/analyses/latest/contributors">hall of fame for the CDK</a>. You’ll see that
<a href="http://wiki.cubic.uni-koeln.de/blog/">Christoph</a>’s research group is the major contributor. User contributions, however,
are equally important and played a bug role in the quite <a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/junitsummary.html">large set of JUnit tests</a>
we have now (3300+).</p>

<p>Another reason why this is an important milestone, is that it is the last release I am creating. I wrote on the user list:</p>

<ul><i>
In advance of the actual CDK 1.0 release, thanx very much to all that contributed big *and* small ! It was a great 7 years of open source
chemoinformatics development!

Hey, that actually sounds like I am stepping down... Well, it *is* time for a new generation to step up indeed. I won't leave the project,
but being CDK News editor, CDK release manager, CDK code developer is a bit much for doing outside office hours. I feel that I have clearly
enough made my point for open source chemoinformatics, and it is time for something else... which will very likely involve the CDK, but
likely more as user only... I was hoping in the past few years, that the transition would go smoothly, and have been trying to get people
interested in various emails, including this one; however, being humans, we wait for the catastrophe and only after that we're shocked and
start doing something about it. So, yeah, I'm forced to make this drastic announcement: CDK 1.0 will be the last CDK release *I* will make.
</i></ul>

<p>So, who wants to take over? Some one will have to. I, however, will put my focus on other things. Very likely involving the CDK, as there
are still many things I want to do. Some things I have on my list:</p>

<ul>
  <li>the Java2D based 2D renderer/editor</li>
  <li>more accurate atom type perception</li>
  <li>more articles for CDK News</li>
  <li>the book “CDK for Dummies”</li>
  <li>improved structure generator</li>
  <li>validation</li>
  <li>…</li>
</ul>]]></content><author><name>Egon Willighagen</name></author><category term="cdk" /><category term="cheminf" /><category term="junit" /><summary type="html"><![CDATA[Last night, I released CDK 1.0 as the previous release candidate did not show up new major problems. It is far from a perfect release (see these still TODO’s and Nightly, run by Rajarshi), but the core is pretty solid.]]></summary></entry><entry><title type="html">Running single JUnit tests in Eclipse</title><link href="http://egonw.github.io/blog/2006/10/26/running-single-junit-tests-in-eclipse.html" rel="alternate" type="text/html" title="Running single JUnit tests in Eclipse" /><published>2006-10-26T00:00:00+00:00</published><updated>2006-10-26T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2006/10/26/running-single-junit-tests-in-eclipse</id><content type="html" xml:base="http://egonw.github.io/blog/2006/10/26/running-single-junit-tests-in-eclipse.html"><![CDATA[<p>Unit testing is important when developing source code. <a href="http://www.junit.org/">JUnit</a> provides a library to facilitate this in Java,
and <a href="http://www.eclipse.org/te">Eclipse</a> had the functionality to run JUnit tests. Even better, it allows you to run single JUnit
tests, even in debug mode:</p>

<p><img src="/blog/assets/images/JUnitTestInDebugMode.png" alt="" /></p>

<p>Just open the java class in your Package Explorer, right click on the JUnit method you want to run, then pick <code class="language-plaintext highlighter-rouge">Run As</code> or <code class="language-plaintext highlighter-rouge">Debug As</code>,
and then <code class="language-plaintext highlighter-rouge">JUnit test</code>.</p>]]></content><author><name>Egon Willighagen</name></author><category term="junit" /><category term="eclipse" /><summary type="html"><![CDATA[Unit testing is important when developing source code. JUnit provides a library to facilitate this in Java, and Eclipse had the functionality to run JUnit tests. Even better, it allows you to run single JUnit tests, even in debug mode:]]></summary></entry><entry><title type="html">CDK Bug Squash Party - Day 5</title><link href="http://egonw.github.io/blog/2006/09/24/cdk-bug-squash-party-day-5.html" rel="alternate" type="text/html" title="CDK Bug Squash Party - Day 5" /><published>2006-09-24T00:00:00+00:00</published><updated>2006-09-24T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2006/09/24/cdk-bug-squash-party-day-5</id><content type="html" xml:base="http://egonw.github.io/blog/2006/09/24/cdk-bug-squash-party-day-5.html"><![CDATA[<p>Day 5 was formally the last day (see also the summaries of <a href="https://chem-bla-ics.linkedchemistry.info/2006/09/18/cdk-bug-squash-party-day-1.html">day 1 <i class="fa-solid fa-recycle fa-xs"></i></a>,
<a href="https://chem-bla-ics.linkedchemistry.info/2006/09/20/cdk-bug-squash-party-day-2.html">day 2 <i class="fa-solid fa-recycle fa-xs"></i></a> and
<a href="https://chem-bla-ics.linkedchemistry.info/2006/09/22/cdk-bug-squash-party-day-3-and-4.html">day 3/4 <i class="fa-solid fa-recycle fa-xs"></i></a>) of the
<a href="http://cdk.sf.net/">Chemistry Development Kit</a> <a href="http://wiki.cubic.uni-koeln.de/cdkwiki/doku.php?id=bsp200609">Bug Squash Party</a> (BSP).
Miguel uploaded the last bits of his CDK <a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/api/org/openscience/cdk/protein/data/PDBPolymer.html">PDBPolymer</a>
to CML to CDK PDBPolymer roundtripping functionality (closing a bug and a feature request in one go). Have not tested this first hand yet,
but looking forward to playing with this bit of code. Kai continued to work on the more difficult bits of the
<a href="http://wiki.cubic.uni-koeln.de/cdkwiki/doku.php?id=refactoringkernelclasses">code refactoring</a>, resulting in fewer though more
comprehensive commits. Stefan fixed another bug in JChemPaint; the rendering of implicit hydrogens.</p>

<p>About the last, the <a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/api/org/openscience/cdk/renderer/Renderer2D.html">Renderer2D</a>
needs a serious overhaul. That is, a complete rewrite in proper Java2D, which can use affine transformations for zooming, scaling and fixing the
coordinate system. The current code is ancient and predates Java2D. <a href="http://depth-first.com/articles/2006/08/28/drawing-2-d-structures-with-structure-cdk">Rich’ code</a>
might be a good starting point. I would love to do this rewrite, but lack the resources… anyone in need of some open source fame?</p>

<p>I worked on atom typing, which is yet largely untested, and often integrated with other bits of code. Yesterday I uploaded
<a href="http://svn.sourceforge.net/viewvc/cdk/trunk/cdk/src/org/openscience/cdk/atomtype/">some first patches</a> which I wrote on the train ride
back to the Netherlands.</p>

<p>Now, what can be concluded from this BSP? The participant count was below what I had hoped for, but those who did worked hard (and
with pleasure I hope :) The total number of JUnit test has increased:</p>

<p><img src="/blog/assets/images/junit_tests.png" alt="" /></p>

<p>And so has the number of failing tests:</p>

<p><img src="/blog/assets/images/fails_tests.png" alt="" /></p>

<p>These plots were made with <a href="http://www.r-project.org/">R</a> from data created with two custom scripts both found in
<a href="http://svn.sourceforge.net/viewvc/cdk/trunk/cdk/tools/">cdk/tools</a>: makeBugCountPlot.pl and extractBugCountPlotData.bsh.
Note that <a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/junitsummary.html">96.86% of the tests do not fail</a>!</p>

<p>The bump in failing tests seems to be due to <a href="http://svn.sourceforge.net/viewvc/cdk/trunk/cdk/src/org/openscience/cdk/smiles/SmilesParser.java?r1=7009&amp;r2=7011">commit 7010-7011</a>,
which has to do with SMILES parsing. Yes, the bond order resolving is still not solved. I don’t seem to get Todd’s patch for this working,
but not giving up either. The bump is so large, because quite some JUnit tests use the SmilesParser as a quick tool to get a configured
connection table. However, these tests should be replaced by explicit CDK models, which is easy done with the
<a href="http://cheminfo.informatics.indiana.edu/~rguha/code/java/nightly/api/org/openscience/cdk/io/CDKSourceCodeWriter.html">CDKSourceCodeWriter</a>.
I’ll blog about how to use that soon.</p>]]></content><author><name>Egon Willighagen</name></author><category term="cdk" /><category term="bsp" /><category term="junit" /><summary type="html"><![CDATA[Day 5 was formally the last day (see also the summaries of day 1 , day 2 and day 3/4 ) of the Chemistry Development Kit Bug Squash Party (BSP). Miguel uploaded the last bits of his CDK PDBPolymer to CML to CDK PDBPolymer roundtripping functionality (closing a bug and a feature request in one go). Have not tested this first hand yet, but looking forward to playing with this bit of code. Kai continued to work on the more difficult bits of the code refactoring, resulting in fewer though more comprehensive commits. Stefan fixed another bug in JChemPaint; the rendering of implicit hydrogens.]]></summary><media:thumbnail xmlns:media="http://search.yahoo.com/mrss/" url="http://egonw.github.io/blog/blog/assets/images/junit_tests.png" /><media:content medium="image" url="http://egonw.github.io/blog/blog/assets/images/junit_tests.png" xmlns:media="http://search.yahoo.com/mrss/" /></entry><entry><title type="html">Nightly CDK builds now available</title><link href="http://egonw.github.io/blog/2006/05/01/nightly-cdk-builds-now-available.html" rel="alternate" type="text/html" title="Nightly CDK builds now available" /><published>2006-05-01T00:00:00+00:00</published><updated>2006-05-01T00:00:00+00:00</updated><id>http://egonw.github.io/blog/2006/05/01/nightly-cdk-builds-now-available</id><content type="html" xml:base="http://egonw.github.io/blog/2006/05/01/nightly-cdk-builds-now-available.html"><![CDATA[<p><a href="http://web.archive.org/web/20060815001811/http://cheminfo.informatics.indiana.edu/~rguha/">Rajarshi Guha <i class="fa-solid fa-box-archive fa-xs"></i></a>
has set a <a href="http://blue.chem.psu.edu/~rajarshi/code/java/nightly/">nightly build service <i class="fa-solid fa-link-slash fa-xs"></i></a>
for the <a href="http://cdk.sf.net/">Chemistry Development Kit</a> (CDK). The output is pretty, but information rich: it includes results for the
<a href="http://www.junit.org/">JUnit test</a>, <a href="http://java.sun.com/j2se/javadoc/doccheck/">DocCheck</a>, and <a href="http://pmd.sourceforge.net/">PMD</a>.
The compiled jar and the corresponding JavaDoc can be downloaded, offering a cutting edge distribution for users.</p>]]></content><author><name>Egon Willighagen</name></author><category term="cdk" /><category term="junit" /><category term="pmd" /><category term="opensource" /><summary type="html"><![CDATA[Rajarshi Guha has set a nightly build service for the Chemistry Development Kit (CDK). The output is pretty, but information rich: it includes results for the JUnit test, DocCheck, and PMD. The compiled jar and the corresponding JavaDoc can be downloaded, offering a cutting edge distribution for users.]]></summary></entry></feed>