1 /* Copyright (C) 2004-2007  The Chemistry Development Kit (CDK) project
2  *
3  * Contact: cdk-devel@lists.sourceforge.net
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public License
7  * as published by the Free Software Foundation; either version 2.1
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19 package org.openscience.cdk.interfaces;
20 
21 import java.util.Comparator;
22 import java.util.Iterator;
23 
24 import org.junit.Assert;
25 import org.junit.Test;
26 import org.mockito.Mockito;
27 import org.openscience.cdk.tools.manipulator.AtomContainerComparator;
28 
29 import static org.hamcrest.CoreMatchers.is;
30 import static org.junit.Assert.assertThat;
31 import static org.mockito.Matchers.any;
32 import static org.mockito.Mockito.verify;
33 
34 /**
35  * Checks the functionality of {@link IAtomContainerSet} implementations.
36  *
37  * @cdk.module test-interfaces
38  */
39 public abstract class AbstractAtomContainerSetTest extends AbstractChemObjectTest {
40 
41     /**
42      * @cdk.bug 3093241
43      */
44     @Test
testSortAtomContainers_Comparator_Null()45     public void testSortAtomContainers_Comparator_Null() {
46         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
47         IChemObjectBuilder builder = som.getBuilder();
48         IAtomContainer con1 = builder.newInstance(IAtomContainer.class);
49         con1.addAtom(builder.newInstance(IAtom.class, "C"));
50         con1.addAtom(builder.newInstance(IAtom.class, "C"));
51         IAtomContainer con2 = builder.newInstance(IAtomContainer.class);
52         con2.addAtom(builder.newInstance(IAtom.class, "C"));
53         som.addAtomContainer(con1);
54         som.addAtomContainer(con2);
55         Assert.assertNotNull(som.getAtomContainer(0));
56         Assert.assertNotNull(som.getAtomContainer(1));
57 
58         AtomContainerComparator comparator = new AtomContainerComparator();
59         som.sortAtomContainers(comparator);
60         Assert.assertNotNull(som.getAtomContainer(0));
61         Assert.assertEquals(1, som.getAtomContainer(0).getAtomCount());
62         Assert.assertNotNull(som.getAtomContainer(1));
63         Assert.assertEquals(2, som.getAtomContainer(1).getAtomCount());
64     }
65 
66     /**
67      * ensure coefficients are sorted also
68      */
69     @Test
testSort_Coefficients()70     public void testSort_Coefficients() {
71 
72         IAtomContainerSet set = (IAtomContainerSet) newChemObject();
73 
74         IChemObjectBuilder builder = set.getBuilder();
75 
76         IAtomContainer a = builder.newInstance(IAtomContainer.class);
77         IAtomContainer b = builder.newInstance(IAtomContainer.class);
78 
79         a.addAtom(builder.newInstance(IAtom.class, "C"));
80         a.addAtom(builder.newInstance(IAtom.class, "C"));
81 
82         b.addAtom(builder.newInstance(IAtom.class, "C"));
83 
84         set.addAtomContainer(a, 1);
85         set.addAtomContainer(b, 2);
86 
87         assertThat(set.getAtomContainer(0), is(a));
88         assertThat(set.getMultiplier(0), is(1D));
89         assertThat(set.getAtomContainer(1), is(b));
90         assertThat(set.getMultiplier(1), is(2D));
91 
92         // sort by atom container count
93         set.sortAtomContainers(new Comparator<IAtomContainer>() {
94 
95             @Override
96             public int compare(IAtomContainer o1, IAtomContainer o2) {
97                 int n = o1.getAtomCount();
98                 int m = o2.getAtomCount();
99                 if (n > m) return +1;
100                 if (n < m) return -1;
101                 return 0;
102             }
103         });
104 
105         assertThat(set.getAtomContainer(0), is(b));
106         assertThat(set.getMultiplier(0), is(2D));
107         assertThat(set.getAtomContainer(1), is(a));
108         assertThat(set.getMultiplier(1), is(1D));
109 
110     }
111 
112     /**
113      * Ensures that sort method of the AtomContainerSet does not include nulls
114      * in the comparator. This is tested using a comparator which sorts null
115      * values as low and thus to the start of an array. By adding two (non-null)
116      * values and sorting we should see that the first two values are not null
117      * despite giving a comparator which sorts null as low.
118      *
119      * @cdk.bug 1291
120      */
121     @Test
testSort_BrokenComparator()122     public void testSort_BrokenComparator() {
123 
124         IAtomContainerSet set = (IAtomContainerSet) newChemObject();
125 
126         IChemObjectBuilder builder = set.getBuilder();
127 
128         IAtomContainer a = builder.newInstance(IAtomContainer.class);
129         IAtomContainer b = builder.newInstance(IAtomContainer.class);
130 
131         a.addAtom(builder.newInstance(IAtom.class, "C"));
132         a.addAtom(builder.newInstance(IAtom.class, "C"));
133 
134         b.addAtom(builder.newInstance(IAtom.class, "C"));
135 
136         set.addAtomContainer(a);
137         set.addAtomContainer(b);
138 
139         // this comparator is deliberately broken but serves for the test
140         //  - null should be a high value (Interger.MAX)
141         //  - also, avoid boxed primitives in comparators
142         set.sortAtomContainers(new Comparator<IAtomContainer>() {
143 
144             @Override
145             public int compare(IAtomContainer o1, IAtomContainer o2) {
146                 return size(o1).compareTo(size(o2));
147             }
148 
149             public Integer size(IAtomContainer container) {
150                 return container == null ? Integer.MIN_VALUE : container.getAtomCount();
151             }
152 
153         });
154 
155         // despite null being low, the two atom containers should
156         // still be in the first slot
157         Assert.assertNotNull(set.getAtomContainer(0));
158         Assert.assertNotNull(set.getAtomContainer(1));
159         Assert.assertNull(set.getAtomContainer(2));
160 
161     }
162 
163     /**
164      * Ensure that sort is not called on an empty set. We mock the comparator
165      * and verify the compare method is never called
166      */
167     @Test
testSort_empty()168     public void testSort_empty() {
169 
170         IAtomContainerSet set = (IAtomContainerSet) newChemObject();
171 
172         @SuppressWarnings("unchecked")
173         Comparator<IAtomContainer> comparator = Mockito.mock(Comparator.class);
174 
175         set.sortAtomContainers(comparator);
176 
177         // verify the comparator was called 0 times
178         verify(comparator, Mockito.times(0)).compare(any(IAtomContainer.class), any(IAtomContainer.class));
179 
180     }
181 
182     @Test
testGetAtomContainerCount()183     public void testGetAtomContainerCount() {
184         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
185         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
186         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
187         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
188 
189         Assert.assertEquals(3, som.getAtomContainerCount());
190     }
191 
192     @Test
testAtomContainers()193     public void testAtomContainers() {
194         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
195         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
196         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
197         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
198 
199         Assert.assertEquals(3, som.getAtomContainerCount());
200         Iterator<IAtomContainer> iter = som.atomContainers().iterator();
201         int count = 0;
202         while (iter.hasNext()) {
203             iter.next();
204             ++count;
205             iter.remove();
206         }
207         Assert.assertEquals(0, som.getAtomContainerCount());
208         Assert.assertEquals(3, count);
209         Assert.assertFalse(iter.hasNext());
210     }
211 
212     @Test
testAdd_IAtomContainerSet()213     public void testAdd_IAtomContainerSet() {
214         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
215         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
216         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
217         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
218 
219         IAtomContainerSet tested = som.getBuilder().newInstance(IAtomContainerSet.class);
220         Assert.assertEquals(0, tested.getAtomContainerCount());
221         tested.add(som);
222         Assert.assertEquals(3, tested.getAtomContainerCount());
223     }
224 
225     @Test
testGetAtomContainer_int()226     public void testGetAtomContainer_int() {
227         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
228         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
229         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
230         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
231 
232         Assert.assertNotNull(som.getAtomContainer(2)); // third molecule should exist
233         Assert.assertNull(som.getAtomContainer(3)); // fourth molecule must not exist
234     }
235 
236     @Test
testGetMultiplier_int()237     public void testGetMultiplier_int() {
238         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
239         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
240 
241         Assert.assertEquals(1.0, som.getMultiplier(0), 0.00001);
242     }
243 
244     @Test
testSetMultiplier_int_Double()245     public void testSetMultiplier_int_Double() {
246         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
247         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
248 
249         Assert.assertEquals(1.0, som.getMultiplier(0), 0.00001);
250         som.setMultiplier(0, 2.0);
251         Assert.assertEquals(2.0, som.getMultiplier(0), 0.00001);
252     }
253 
254     @Test
testSetMultipliers_arrayDouble()255     public void testSetMultipliers_arrayDouble() {
256         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
257         IAtomContainer container = som.getBuilder().newInstance(IAtomContainer.class);
258         som.addAtomContainer(container);
259         IAtomContainer container2 = som.getBuilder().newInstance(IAtomContainer.class);
260         som.addAtomContainer(container2);
261 
262         Assert.assertEquals(1.0, som.getMultiplier(0), 0.00001);
263         Assert.assertEquals(1.0, som.getMultiplier(1), 0.00001);
264         Double[] multipliers = new Double[2];
265         multipliers[0] = 2.0;
266         multipliers[1] = 3.0;
267         som.setMultipliers(multipliers);
268         Assert.assertEquals(2.0, som.getMultiplier(0), 0.00001);
269         Assert.assertEquals(3.0, som.getMultiplier(1), 0.00001);
270     }
271 
272     @Test
testSetMultiplier_IAtomContainer_Double()273     public void testSetMultiplier_IAtomContainer_Double() {
274         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
275         IAtomContainer container = som.getBuilder().newInstance(IAtomContainer.class);
276         som.addAtomContainer(container);
277 
278         Assert.assertEquals(1.0, som.getMultiplier(container), 0.00001);
279         som.setMultiplier(container, 2.0);
280         Assert.assertEquals(2.0, som.getMultiplier(container), 0.00001);
281     }
282 
283     @Test
testGetMultipliers()284     public void testGetMultipliers() {
285         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
286         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class), 1.0);
287 
288         Double[] multipliers = som.getMultipliers();
289         Assert.assertNotNull(multipliers);
290         Assert.assertEquals(1, multipliers.length);
291     }
292 
293     @Test
testGetMultiplier_IAtomContainer()294     public void testGetMultiplier_IAtomContainer() {
295         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
296         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
297 
298         Assert.assertEquals(-1.0, som.getMultiplier(som.getBuilder().newInstance(IAtomContainer.class)), 0.00001);
299     }
300 
301     @Test
testAddAtomContainer_IAtomContainer()302     public void testAddAtomContainer_IAtomContainer() {
303         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
304         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
305         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
306         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
307         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
308         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
309 
310         Assert.assertEquals(5, som.getAtomContainerCount());
311 
312         // now test it to make sure it properly grows the array
313         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
314         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
315 
316         Assert.assertEquals(7, som.getAtomContainerCount());
317     }
318 
319     @Test
testAddAtomContainer_IAtomContainer_double()320     public void testAddAtomContainer_IAtomContainer_double() {
321         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
322         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class), 2.0);
323         Assert.assertEquals(1, som.getAtomContainerCount());
324         Assert.assertEquals(2.0, som.getMultiplier(0), 0.00001);
325     }
326 
327     @Test
testGrowAtomContainerArray()328     public void testGrowAtomContainerArray() {
329         // this test assumes that the growSize = 5 !
330         // if not, there is need for the array to grow
331         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
332 
333         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
334         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
335         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
336         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
337         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
338         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
339         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
340 
341         Assert.assertEquals(7, som.getAtomContainerCount());
342     }
343 
344     @Test
testGetAtomContainers()345     public void testGetAtomContainers() {
346         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
347 
348         Assert.assertEquals(0, som.getAtomContainerCount());
349 
350         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
351         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
352         som.addAtomContainer(som.getBuilder().newInstance(IAtomContainer.class));
353 
354         Assert.assertEquals(3, som.getAtomContainerCount());
355         Assert.assertNotNull(som.getAtomContainer(0));
356         Assert.assertNotNull(som.getAtomContainer(1));
357         Assert.assertNotNull(som.getAtomContainer(2));
358     }
359 
360     @Test
testToString()361     public void testToString() {
362         IAtomContainerSet containerSet = (IAtomContainerSet) newChemObject();
363         String description = containerSet.toString();
364         for (int i = 0; i < description.length(); i++) {
365             Assert.assertTrue(description.charAt(i) != '\n');
366             Assert.assertTrue(description.charAt(i) != '\r');
367         }
368     }
369 
370     @Override
371     @Test
testClone()372     public void testClone() throws Exception {
373         IAtomContainerSet containerSet = (IAtomContainerSet) newChemObject();
374         Object clone = containerSet.clone();
375         Assert.assertTrue(clone instanceof IAtomContainerSet);
376         Assert.assertNotSame(containerSet, clone);
377     }
378 
379     @Test
testCloneDuplication()380     public void testCloneDuplication() throws Exception {
381         IAtomContainerSet containerSet = (IAtomContainerSet) newChemObject();
382         containerSet.addAtomContainer(containerSet.getBuilder().newInstance(IAtomContainer.class));
383         Object clone = containerSet.clone();
384         Assert.assertTrue(clone instanceof IAtomContainerSet);
385         IAtomContainerSet clonedSet = (IAtomContainerSet) clone;
386         Assert.assertNotSame(containerSet, clonedSet);
387         Assert.assertEquals(containerSet.getAtomContainerCount(), clonedSet.getAtomContainerCount());
388     }
389 
390     @Test
testCloneMultiplier()391     public void testCloneMultiplier() throws Exception {
392         IAtomContainerSet containerSet = (IAtomContainerSet) newChemObject();
393         containerSet.addAtomContainer(containerSet.getBuilder().newInstance(IAtomContainer.class), 2);
394         Object clone = containerSet.clone();
395         Assert.assertTrue(clone instanceof IAtomContainerSet);
396         IAtomContainerSet clonedSet = (IAtomContainerSet) clone;
397         Assert.assertNotSame(containerSet, clonedSet);
398         Assert.assertEquals(2, containerSet.getMultiplier(0).intValue());
399         Assert.assertEquals(2, clonedSet.getMultiplier(0).intValue());
400     }
401 
402     @Override
403     @Test
testStateChanged_IChemObjectChangeEvent()404     public void testStateChanged_IChemObjectChangeEvent() {
405         ChemObjectListenerImpl listener = new ChemObjectListenerImpl();
406         IAtomContainerSet chemObject = (IAtomContainerSet) newChemObject();
407         chemObject.addListener(listener);
408 
409         chemObject.addAtomContainer(chemObject.getBuilder().newInstance(IAtomContainer.class));
410         Assert.assertTrue(listener.changed);
411     }
412 
413     @Test
testRemoveAtomContainer_IAtomContainer()414     public void testRemoveAtomContainer_IAtomContainer() {
415         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
416         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
417         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
418         som.addAtomContainer(ac1);
419         som.addAtomContainer(ac2);
420         som.removeAtomContainer(ac1);
421         Assert.assertEquals(1, som.getAtomContainerCount());
422         Assert.assertEquals(ac2, som.getAtomContainer(0));
423     }
424 
425     @Test
testRemoveAllAtomContainers()426     public void testRemoveAllAtomContainers() {
427         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
428         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
429         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
430         som.addAtomContainer(ac1);
431         som.addAtomContainer(ac2);
432 
433         Assert.assertEquals(2, som.getAtomContainerCount());
434         som.removeAllAtomContainers();
435         Assert.assertEquals(0, som.getAtomContainerCount());
436     }
437 
438     @Test
testRemoveAtomContainer_int()439     public void testRemoveAtomContainer_int() {
440         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
441         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
442         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
443         som.addAtomContainer(ac1);
444         som.addAtomContainer(ac2);
445         som.removeAtomContainer(0);
446         Assert.assertEquals(1, som.getAtomContainerCount());
447         Assert.assertEquals(ac2, som.getAtomContainer(0));
448     }
449 
450     /*
451      * @cdk.bug 2679343
452      */
453     @Test
testBug2679343()454     public void testBug2679343() {
455         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
456         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
457         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
458         som.addAtomContainer(ac1);
459         som.addAtomContainer(ac2);
460         som.addAtomContainer(ac2);
461         Assert.assertEquals(3, som.getAtomContainerCount());
462         som.removeAtomContainer(ac2);
463         Assert.assertEquals(1, som.getAtomContainerCount());
464     }
465 
466     @Test
testReplaceAtomContainer_int_IAtomContainer()467     public void testReplaceAtomContainer_int_IAtomContainer() {
468         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
469         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
470         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
471         IAtomContainer ac3 = som.getBuilder().newInstance(IAtomContainer.class);
472         som.addAtomContainer(ac1);
473         som.addAtomContainer(ac2);
474         Assert.assertEquals(ac2, som.getAtomContainer(1));
475         som.replaceAtomContainer(1, ac3);
476         Assert.assertEquals(ac3, som.getAtomContainer(1));
477     }
478 
479     @Test
testSortAtomContainers_Comparator()480     public void testSortAtomContainers_Comparator() {
481         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
482         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
483         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
484         som.addAtomContainer(ac1);
485         som.addAtomContainer(ac2);
486         som.sortAtomContainers(new Comparator<IAtomContainer>() {
487 
488             @Override
489             public int compare(IAtomContainer o1, IAtomContainer o2) {
490                 return 0;
491             }
492         });
493         Assert.assertEquals(2, som.getAtomContainerCount());
494     }
495 
496     @Test
testSortAtomContainers_WithMuliplier()497     public void testSortAtomContainers_WithMuliplier() {
498         IAtomContainerSet som = (IAtomContainerSet) newChemObject();
499         IAtomContainer ac1 = som.getBuilder().newInstance(IAtomContainer.class);
500         som.addAtomContainer(ac1, 2.0);
501         ac1.setProperty("multiplierSortCode", "2");
502         IAtomContainer ac2 = som.getBuilder().newInstance(IAtomContainer.class);
503         som.addAtomContainer(ac2, 1.0);
504         ac2.setProperty("multiplierSortCode", "1");
505         som.sortAtomContainers(new Comparator<IAtomContainer>() {
506 
507             @Override
508             public int compare(IAtomContainer o1, IAtomContainer o2) {
509                 return ((String) o1.getProperty("multiplierSortCode")).compareTo((String) o2
510                         .getProperty("multiplierSortCode"));
511             }
512         });
513         Assert.assertEquals(2, som.getAtomContainerCount());
514         IAtomContainer newFirstAC = som.getAtomContainer(0);
515         Assert.assertEquals(newFirstAC.getProperty("multiplierSortCode"), "1");
516         // OK, sorting worked as intended
517         // The multiplier should have been resorted too:
518         Assert.assertEquals(1.0, som.getMultiplier(newFirstAC), 0.00001);
519     }
520 
521     protected class ChemObjectListenerImpl implements IChemObjectListener {
522 
523         private boolean changed;
524 
ChemObjectListenerImpl()525         private ChemObjectListenerImpl() {
526             changed = false;
527         }
528 
529         @Test
530         @Override
stateChanged(IChemObjectChangeEvent e)531         public void stateChanged(IChemObjectChangeEvent e) {
532             changed = true;
533         }
534 
535         @Test
reset()536         public void reset() {
537             changed = false;
538         }
539     }
540 
541     @Test
testIsEmpty()542     public void testIsEmpty() {
543 
544         IAtomContainerSet set = (IAtomContainerSet) newChemObject();
545 
546         Assert.assertTrue("new container set should be empty", set.isEmpty());
547 
548         set.addAtomContainer(set.getBuilder().newInstance(IAtomContainer.class));
549 
550         Assert.assertFalse("container set with a single container should not be empty", set.isEmpty());
551 
552         set.removeAllAtomContainers();
553 
554         Assert.assertTrue("container set with all containers removed should be empty", set.isEmpty());
555 
556     }
557 
558 }
559