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