public void verifyNodeCache(int size, Object factory) {
   assertEquals(size, ((Integer) ObjectTools.get(factory, "cacheSize")).intValue());
   int nodeCount = 0;
   for (Object node = ObjectTools.get(factory, "cacheHead");
       node != null;
       node = ObjectTools.get(node, "next")) {
     nodeCount++;
   }
   assertEquals(size, nodeCount);
 }
 public void setSpecifiedUnique(Boolean unique) {
   if (ObjectTools.notEquals(this.specifiedUnique, unique)) {
     this.getColumnAnnotation().setUnique(unique);
     this.removeColumnAnnotationIfUnset();
     this.setSpecifiedUnique_(unique);
   }
 }
 public void setSpecifiedNullable(Boolean nullable) {
   if (ObjectTools.notEquals(this.specifiedNullable, nullable)) {
     this.getColumnAnnotation().setNullable(nullable);
     this.removeColumnAnnotationIfUnset();
     this.setSpecifiedNullable_(nullable);
   }
 }
 public void setSpecifiedInsertable(Boolean insertable) {
   if (ObjectTools.notEquals(this.specifiedInsertable, insertable)) {
     this.getColumnAnnotation().setInsertable(insertable);
     this.removeColumnAnnotationIfUnset();
     this.setSpecifiedInsertable_(insertable);
   }
 }
 public void setSpecifiedUpdatable(Boolean updatable) {
   if (ObjectTools.notEquals(this.specifiedUpdatable, updatable)) {
     this.getColumnAnnotation().setUpdatable(updatable);
     this.removeColumnAnnotationIfUnset();
     this.setSpecifiedUpdatable_(updatable);
   }
 }
 public void setSpecifiedTableName(String tableName) {
   if (ObjectTools.notEquals(this.specifiedTableName, tableName)) {
     this.getColumnAnnotation().setTable(tableName);
     this.removeColumnAnnotationIfUnset();
     this.setSpecifiedTableName_(tableName);
   }
 }
 public void setSpecifiedNullable(Boolean nullable) {
   if (ObjectTools.notEquals(this.specifiedNullable, nullable)) {
     XmlOrderColumn xmlColumn = this.getXmlColumnForUpdate();
     this.setSpecifiedNullable_(nullable);
     xmlColumn.setNullable(nullable);
     this.removeXmlColumnIfUnset();
   }
 }
  public void testSize() {
    Queue<String> queue = this.buildQueue();
    String first = "first";
    String second = "second";
    String third = "third";

    assertEquals(0, ((Integer) ObjectTools.execute(queue, "size")).intValue());
    queue.enqueue(first);
    queue.enqueue(second);
    assertEquals(2, ((Integer) ObjectTools.execute(queue, "size")).intValue());
    queue.enqueue(third);
    assertEquals(3, ((Integer) ObjectTools.execute(queue, "size")).intValue());
    queue.dequeue();
    assertEquals(2, ((Integer) ObjectTools.execute(queue, "size")).intValue());
    queue.dequeue();
    queue.dequeue();
    assertEquals(0, ((Integer) ObjectTools.execute(queue, "size")).intValue());
  }
  public void testNodeCache_unlimited() {
    Queue<String> queue = new LinkedQueue<String>(-1);
    String first = "first";
    String second = "second";
    String third = "third";
    String fourth = "fourth";
    String fifth = "fifth";

    Object factory = ObjectTools.get(queue, "nodeFactory");

    this.verifyNodeCache(0, factory);
    queue.enqueue(first);
    this.verifyNodeCache(0, factory);
    queue.enqueue(second);
    queue.enqueue(third);
    queue.enqueue(fourth);
    queue.enqueue(fifth);
    this.verifyNodeCache(0, factory);
    assertNull(ObjectTools.get(factory, "cacheHead"));

    queue.dequeue();
    this.verifyNodeCache(1, factory);
    queue.dequeue();
    this.verifyNodeCache(2, factory);
    queue.dequeue();
    this.verifyNodeCache(3, factory);
    queue.dequeue();
    this.verifyNodeCache(4, factory);
    queue.dequeue();
    this.verifyNodeCache(5, factory);
    queue.enqueue(first);
    this.verifyNodeCache(4, factory);
    queue.enqueue(second);
    this.verifyNodeCache(3, factory);
    queue.enqueue(third);
    this.verifyNodeCache(2, factory);
    queue.enqueue(fourth);
    this.verifyNodeCache(1, factory);
    queue.enqueue(fifth);
    this.verifyNodeCache(0, factory);
  }
  public void testBuildElements() {
    Queue<String> queue = this.buildQueue();
    String first = "first";
    String second = "second";
    String third = "third";
    queue.enqueue(first);
    queue.enqueue(second);
    queue.enqueue(third);

    Object[] elements = new Object[] {first, second, third};
    assertTrue(Arrays.equals(elements, ((Object[]) ObjectTools.execute(queue, "buildElements"))));
  }
 /** test method that has more general method parameter type */
 public void testSingleArgumentNamedProperty2() throws Exception {
   TestModel testModel = new TestModel(7);
   Target target = new Target(testModel, TestModel.VALUE_PROPERTY, 7, 99);
   Method method =
       ObjectTools.method(target, "propertyChangedSingleArgument2", new Class[] {Object.class});
   testModel.addPropertyChangeListener(
       TestModel.VALUE_PROPERTY,
       ReflectiveChangeListener.buildPropertyChangeListener(target, method));
   testModel.setValue(99);
   assertFalse(target.zeroArgumentFlag);
   assertTrue(target.singleArgumentFlag);
 }
  public void testNodeToString() {
    Queue<String> queue = QueueTools.linkedQueue();
    String first = "first";
    String second = "second";
    String third = "third";
    queue.enqueue(first);
    queue.enqueue(second);
    queue.enqueue(third);

    Object head = ObjectTools.get(queue, "head");
    assertTrue(head.toString().startsWith("LinkedQueue.Node"));
    assertTrue(head.toString().endsWith("(first)"));
  }
  public void testSerialization_caching() throws Exception {
    Queue<String> original = QueueTools.linkedQueue(20);
    original.enqueue("first");

    Queue<String> clone = TestTools.serialize(original);
    assertEquals(original.peek(), clone.peek());
    assertEquals(original.dequeue(), clone.dequeue());
    assertNotSame(original, clone);
    assertTrue(original.isEmpty());
    assertEquals(original.isEmpty(), clone.isEmpty());

    original.enqueue("second");
    assertFalse(original.isEmpty());
    // clone should still be empty
    assertTrue(clone.isEmpty());

    Object factory = ObjectTools.get(original, "nodeFactory");
    assertTrue(factory.toString().startsWith("LinkedQueue.CachingNodeFactory"));
  }
 public void testBogusDoubleArgument2() throws Exception {
   TestModel testModel = new TestModel(7);
   Target target = new Target(testModel, TestModel.VALUE_PROPERTY, 7, 99);
   Method method =
       ObjectTools.method(
           target,
           "propertyChangedDoubleArgument",
           new Class[] {PropertyChangeEvent.class, Object.class});
   boolean exCaught = false;
   try {
     PropertyChangeListener listener =
         ReflectiveChangeListener.buildPropertyChangeListener(target, method);
     fail("bogus listener: " + listener);
   } catch (RuntimeException ex) {
     if (ex.getMessage().equals(method.toString())) {
       exCaught = true;
     }
   }
   assertTrue(exCaught);
 }
 @Override
 public String toString() {
   return ObjectTools.toString(this, this.transformer);
 }
 @Override
 public String toString() {
   return ObjectTools.toString(this, this.selection);
 }
 public void setValue(String value) {
   if (ObjectTools.notEquals(this.value, value)) {
     this.value = value;
     this.valueAdapter.setValue(value);
   }
 }
 public void setLength(Integer length) {
   if (ObjectTools.notEquals(this.length, length)) {
     this.length = length;
     this.lengthAdapter.setValue(length);
   }
 }
 public void setScale(Integer scale) {
   if (ObjectTools.notEquals(this.scale, scale)) {
     this.scale = scale;
     this.scaleAdapter.setValue(scale);
   }
 }
 public void setPrecision(Integer precision) {
   if (ObjectTools.notEquals(this.precision, precision)) {
     this.precision = precision;
     this.precisionAdapter.setValue(precision);
   }
 }
 @Override
 public String toString() {
   return ObjectTools.toString(this, this.command);
 }
Пример #22
0
 @Override
 public String toString() {
   return ObjectTools.toString(this, this.driver);
 }
 private boolean elementIs(Object o) {
   return ObjectTools.equals(o, this.getElement());
 }
 @Override
 public String toString() {
   return ObjectTools.toString(this, this.stack);
 }
 public void testSimpleNodeFactoryToString() {
   Queue<String> queue = QueueTools.linkedQueue();
   Object factory = ObjectTools.get(queue, "nodeFactory");
   assertEquals("LinkedQueue.SimpleNodeFactory", factory.toString());
 }
 public void testCachingNodeFactoryToString() {
   Queue<String> queue = QueueTools.linkedQueue(20);
   Object factory = ObjectTools.get(queue, "nodeFactory");
   assertTrue(factory.toString().startsWith("LinkedQueue.CachingNodeFactory"));
   assertTrue(factory.toString().endsWith("(0)"));
 }
 @Override
 public String toString() {
   return ObjectTools.toString(this, this.valueModel);
 }
 protected Iterable<PersistentType> buildInheritanceHierarchy(PersistentType start) {
   // using a chain iterable to traverse up the inheritance tree
   return ObjectTools.chain(start, SUPER_PERSISTENT_TYPE_TRANSFORMER);
 }
 /**
  * If there is a specified table name it needs to be the same the default table name. the table
  * is always the collection table
  */
 public boolean tableNameIsInvalid(String tableName) {
   return ObjectTools.notEquals(this.getDefaultTableName(), tableName);
 }
Пример #30
0
 @Override
 public String toString() {
   return ObjectTools.toString(this);
 }