Ejemplo n.º 1
0
  public void testClone() throws Exception {
    String[] names = new String[] {"name", "descriptorType"};
    Object[] values = new Object[] {"testName", "testType"};
    DescriptorSupport descriptor = new DescriptorSupport(names, values);

    DescriptorSupport clone = (DescriptorSupport) descriptor.clone();
    compareFields(descriptor.getFields(), clone.getFields());
  }
Ejemplo n.º 2
0
  public void testGetFieldValues() throws Exception {
    String[] names = new String[] {"name", "descriptorType"};
    String[] values = new String[] {"testName", "testType"};
    DescriptorSupport descriptor = new DescriptorSupport(names, values);

    Object[] result = descriptor.getFieldValues(null);
    compareFieldValuesUnsorted(values, result);

    result = descriptor.getFieldValues(new String[0]);
    compareFieldValues(new Object[0], result);

    result = descriptor.getFieldValues(names);
    compareFieldValues(values, result);

    result = descriptor.getFieldValues(new String[] {"name"});
    compareFieldValues(new Object[] {"testName"}, result);

    result = descriptor.getFieldValues(new String[] {"descriptorType", "name"});
    compareFieldValues(new Object[] {"testType", "testName"}, result);

    result = descriptor.getFieldValues(new String[] {"NAME"});
    compareFieldValues(new Object[] {"testName"}, result);

    result = descriptor.getFieldValues(new String[] {null});
    compareFieldValues(new Object[] {null}, result);

    result = descriptor.getFieldValues(new String[] {""});
    compareFieldValues(new Object[] {null}, result);
  }
Ejemplo n.º 3
0
  public void testSizeConstructor() throws Exception {
    DescriptorSupport descriptor = new DescriptorSupport(100);
    assertTrue("Should be empty", descriptor.getFields().length == 0);
    assertFalse("Should not be valid", descriptor.isValid());

    boolean caught = false;
    try {
      descriptor = new DescriptorSupport(-1);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for a negative size", caught);
  }
Ejemplo n.º 4
0
  public void testSerialization() throws Exception {
    String[] names = new String[] {"name", "descriptorType"};
    Object[] values = new Object[] {"testName", "testType"};
    DescriptorSupport descriptor = new DescriptorSupport(names, values);

    // Serialize it
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    oos.writeObject(descriptor);

    // Deserialize it
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bais);
    Object result = ois.readObject();

    compareFields(descriptor.getFields(), ((DescriptorSupport) result).getFields());
  }
Ejemplo n.º 5
0
  public void testGetFieldValue() throws Exception {
    String[] fields = new String[] {"name=testName", "descriptorType=testType"};
    DescriptorSupport descriptor = new DescriptorSupport(fields);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertTrue(
        "Field names are not case sensitive", "testName".equals(descriptor.getFieldValue("NAME")));
    assertTrue(
        "Non existent field should be null", descriptor.getFieldValue("nonExistent") == null);

    boolean caught = false;
    try {
      descriptor.getFieldValue(null);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for null name", caught);

    caught = false;
    try {
      descriptor.getFieldValue("");
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for empty name", caught);

    // This is legal?
    assertTrue("Blank field name is allowed", descriptor.getFieldValue(" ") == null);
  }
Ejemplo n.º 6
0
 public void testNameEqualsValueConstructorError() throws Exception {
   try {
     String[] fields = new String[] {"name=testName", "descriptorType=testType", "another="};
     DescriptorSupport descriptor = new DescriptorSupport(fields);
     assertTrue("Should be three fields", descriptor.getFields().length == 3);
     assertEquals("testName", descriptor.getFieldValue("name"));
     assertEquals("testType", descriptor.getFieldValue("descriptorType"));
     assertTrue("another should be null", descriptor.getFieldValue("another") == null);
     assertTrue("Should be valid", descriptor.isValid());
   } catch (Exception e) {
     fail("FAILS IN RI: 'another=' should be valid according to the javadoc " + e.toString());
   }
 }
Ejemplo n.º 7
0
  public void testNamesValuesConstructor() throws Exception {
    String[] names = new String[] {"name", "descriptorType"};
    Object[] values = new Object[] {"testName", "testType"};
    DescriptorSupport descriptor = new DescriptorSupport(names, values);
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));
    assertTrue("Should be valid", descriptor.isValid());

    descriptor = new DescriptorSupport(new String[0], new Object[0]);
    assertTrue("Should be empty", descriptor.getFields().length == 0);
    assertFalse("Should not be valid", descriptor.isValid());

    boolean caught = false;
    try {
      descriptor = new DescriptorSupport(null, null);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for null names and values", caught);

    caught = false;
    try {
      descriptor = new DescriptorSupport(null, values);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for null names", caught);

    caught = false;
    try {
      descriptor = new DescriptorSupport(names, null);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for null values", caught);

    Object[] tooManyValues = new Object[] {"testName", "testType", "tooMany"};
    caught = false;
    try {
      descriptor = new DescriptorSupport(names, tooManyValues);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for too many values", caught);

    Object[] tooFewValues = new Object[] {"testName"};
    caught = false;
    try {
      descriptor = new DescriptorSupport(names, tooFewValues);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for too few values", caught);

    String[] nullName = new String[] {"name", null};
    caught = false;
    try {
      descriptor = new DescriptorSupport(nullName, values);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for null name", caught);

    String[] emptyName = new String[] {"name", ""};
    caught = false;
    try {
      descriptor = new DescriptorSupport(emptyName, values);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for empty name ", caught);

    // This is legal?
    String[] notEmptyName = new String[] {"name", " "};
    descriptor = new DescriptorSupport(notEmptyName, values);
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue(" "));
    assertFalse("Should not be valid", descriptor.isValid());

    names = new String[] {"name", "descriptorType", "another"};
    values = new Object[] {"testName", "testType", null};
    descriptor = new DescriptorSupport(names, values);
    assertTrue("Should be three fields", descriptor.getFields().length == 3);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));
    assertTrue("another should be null", descriptor.getFieldValue("another") == null);
    assertTrue("Should be valid", descriptor.isValid());
  }
Ejemplo n.º 8
0
  private void validate(String[] names, Object[] values, boolean valid) {
    DescriptorSupport descriptor = null;
    RuntimeOperationsException caught = null;
    boolean descriptorValid = false;
    try {
      descriptor = new DescriptorSupport(names, values);
      descriptorValid = descriptor.isValid();
    } catch (RuntimeOperationsException e) {
      caught = e;
    }
    if (valid && caught != null) throw caught;
    assertEquals(
        "Expected "
            + valid
            + " for new Descriptor(String[], String[]) names="
            + Arrays.asList(names)
            + " values="
            + Arrays.asList(values),
        valid,
        descriptorValid);

    caught = null;
    descriptorValid = false;
    try {
      String[] fields = new String[names.length];
      for (int i = 0; i < fields.length; i++) {
        if (values[i] == null) fields[i] = names[i] + "=";
        else fields[i] = names[i] + "=" + values[i].toString();
      }
      descriptor = new DescriptorSupport(names, values);
      descriptorValid = descriptor.isValid();
    } catch (RuntimeOperationsException e) {
      caught = e;
    }
    if (valid && caught != null) throw caught;
    assertEquals(
        "Expected "
            + valid
            + " for new Descriptor(String[], String[]) names="
            + Arrays.asList(names)
            + " values="
            + Arrays.asList(values),
        valid,
        descriptorValid);

    caught = null;
    descriptorValid = false;
    try {
      descriptor = new DescriptorSupport();
      for (int i = 0; i < names.length; i++) descriptor.setField(names[i], values[i]);
      descriptorValid = descriptor.isValid();
    } catch (RuntimeOperationsException e) {
      caught = e;
    }
    if (valid && caught != null) throw caught;
    assertEquals(
        "Expected "
            + valid
            + " for new Descriptor(String[], String[]) names="
            + Arrays.asList(names)
            + " values="
            + Arrays.asList(values),
        valid,
        descriptorValid);

    caught = null;
    descriptorValid = false;
    try {
      descriptor = new DescriptorSupport();
      descriptor.setFields(names, values);
      descriptorValid = descriptor.isValid();
    } catch (RuntimeOperationsException e) {
      caught = e;
    }
    if (valid && caught != null) throw caught;
    assertEquals(
        "Expected "
            + valid
            + " for new Descriptor(String[], String[]) names="
            + Arrays.asList(names)
            + " values="
            + Arrays.asList(values),
        valid,
        descriptorValid);
  }
Ejemplo n.º 9
0
  public void testCopyConstructor() throws Exception {
    DescriptorSupport descriptor = new DescriptorSupport((DescriptorSupport) null);
    assertTrue("Should be empty", descriptor.getFields().length == 0);
    assertFalse("Should not be valid", descriptor.isValid());

    descriptor = new DescriptorSupport(descriptor);
    assertTrue("Should be empty", descriptor.getFields().length == 0);
    assertFalse("Should not be valid", descriptor.isValid());

    descriptor.setField("name", "testName");
    descriptor.setField("descriptorType", "testType");
    descriptor = new DescriptorSupport(descriptor);
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));
    assertTrue("Should be valid", descriptor.isValid());
  }
Ejemplo n.º 10
0
 public void testDefaultConstructor() throws Exception {
   DescriptorSupport descriptor = new DescriptorSupport();
   assertTrue("Should be empty", descriptor.getFields().length == 0);
   assertFalse("Should not be valid", descriptor.isValid());
 }
Ejemplo n.º 11
0
  public void testRemove() throws Exception {
    String[] names = new String[] {"name", "descriptorType"};
    Object[] values = new Object[] {"testName", "testType"};
    DescriptorSupport descriptor = new DescriptorSupport(names, values);

    descriptor.removeField("name");
    assertTrue("Should be one field", descriptor.getFields().length == 1);
    assertTrue("name should not be present", descriptor.getFieldValue("name") == null);
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));

    descriptor = new DescriptorSupport(names, values);
    descriptor.removeField("NAME");
    assertTrue("Should be one field", descriptor.getFields().length == 1);
    assertTrue("name should not be present", descriptor.getFieldValue("name") == null);
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));

    descriptor = new DescriptorSupport(names, values);
    descriptor.removeField("notPresent");
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));

    descriptor.removeField(null);
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));

    descriptor.removeField("");
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));
  }
Ejemplo n.º 12
0
 public void testGetFieldNames() throws Exception {
   String[] fields = new String[] {"name=testName", "descriptorType=testType"};
   DescriptorSupport descriptor = new DescriptorSupport(fields);
   String[] names = descriptor.getFieldNames();
   compareFieldNames(fields, names);
 }
Ejemplo n.º 13
0
  public void testSetFieldValue() throws Exception {
    String[] fields = new String[] {"name=testName", "descriptorType=testType"};
    DescriptorSupport descriptor = new DescriptorSupport(fields);
    assertEquals("testName", descriptor.getFieldValue("name"));
    descriptor.setField("name", "newName");
    assertEquals("newName", descriptor.getFieldValue("name"));
    descriptor.setField("NAME", "newNAME");
    assertEquals("newNAME", descriptor.getFieldValue("name"));

    boolean caught = false;
    try {
      descriptor.setField(null, "null");
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for null name", caught);

    caught = false;
    try {
      descriptor.setField("", "empty");
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for empty name", caught);

    // This is legal?
    descriptor.setField(" ", "blank");
    assertEquals("blank", descriptor.getFieldValue(" "));

    descriptor.setField("newField", "newValue");
    assertEquals("newValue", descriptor.getFieldValue("newField"));
  }
Ejemplo n.º 14
0
  public void testNameEqualsValueConstructor() throws Exception {
    String[] fields = new String[] {"name=testName", "descriptorType=testType"};
    DescriptorSupport descriptor = new DescriptorSupport(fields);
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("testType", descriptor.getFieldValue("descriptorType"));
    assertTrue("Should be valid", descriptor.isValid());

    descriptor = new DescriptorSupport((String[]) null);
    assertTrue("Should be empty", descriptor.getFields().length == 0);
    assertFalse("Should not be valid", descriptor.isValid());

    descriptor = new DescriptorSupport(new String[0]);
    assertTrue("Should be empty", descriptor.getFields().length == 0);
    assertFalse("Should not be valid", descriptor.isValid());

    String[] nullName = new String[] {"name=testName", "=rubbish"};
    boolean caught = false;
    try {
      descriptor = new DescriptorSupport(nullName);
    } catch (RuntimeOperationsException e) {
      caught = true;
    }
    assertTrue("Expected an exception for '=rubbish'", caught);

    // This is legal?
    String[] notEmptyName = new String[] {"name=testName", " =rubbish"};
    descriptor = new DescriptorSupport(notEmptyName);
    assertTrue("Should be two fields", descriptor.getFields().length == 2);
    assertEquals("testName", descriptor.getFieldValue("name"));
    assertEquals("rubbish", descriptor.getFieldValue(" "));
    assertFalse("Should not be valid", descriptor.isValid());
  }