New tests for messaging plumbing to replace old ones:

kenneth_suter

17.23.2007 5fa20ea2d54d21a781d07995e27113b4c3bbc953

 opends/tests/unit-tests-testng/src/server/org/opends/messages/MessageDescriptorRegistryTest.java

@@ -30,6 +30,17 @@
import static org.testng.Assert.*;
import org.testng.annotations.*;

import java.util.Set;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.ArrayList;
import java.util.Locale;
import java.util.EnumSet;
import java.util.Map;
import java.util.HashMap;
import java.lang.reflect.Field;

/**
 * MessageDescriptorRegistry Tester.
 *
@@ -46,8 +57,95 @@

  @Test(dataProvider = "message descriptors")
  public void testGetMessageDescriptor(MessageDescriptor md) {
    assertEquals(md,
            MessageDescriptorRegistry.getMessageDescriptor(md.getId()));
    MessageDescriptor md2 = MessageDescriptorRegistry.getMessageDescriptor(md.getId());
    assertEquals(md, md2);
  }

  @DataProvider(name = "message classes")
  public Object[][] getMessageClasses() {
    Set<Class> mdClasses = MessageDescriptorRegistry.getRegisteredClasses();
    List<Class> classesToTest = new ArrayList<Class>(mdClasses);

    // These newer message files don't comply
    classesToTest.remove(AdminToolMessages.class);
    classesToTest.remove(QuickSetupMessages.class);

    Object[][] ret = new Object[classesToTest.size()][1];
    for (int i = 0; i < ret.length; i++) {
      ret[i] = new Object[] { classesToTest.get(i) };
    }
    return ret;
  }

  /**
   * Tests that messages don't end with a period (.) excluding those that end
   * with an ellipsis (...)
   * 
   * @param  messagesClass containing definitions of MessageDescriptor objects
   * @throws IllegalAccessException if there is a problem accessing the
   *         class through reflection
   */
  @Test(dataProvider = "message classes")
  public void testFormatStringsDontEndWithPeriod(Class messagesClass)
          throws IllegalAccessException
  {
    Field[] fa = messagesClass.getFields();
    if (fa != null) {
      for (Field f : fa) {
        Class<?> c = f.getType();
        if (MessageDescriptor.class.isAssignableFrom(c)) {
          MessageDescriptor md = (MessageDescriptor)f.get(null);
          String fmtString = md.getFormatString(Locale.getDefault());
          boolean bad = fmtString.endsWith(".") && !fmtString.endsWith("...");
          assertFalse(bad,
                  "Format string for message descriptor " + f.getName() +
                  " obtained through key " + md.getKey() + 
                  " defined in class " + messagesClass.getName() +
                  " \'" + md.getFormatString(Locale.getDefault()) +
                  "\' ends with a '.'");
        }
      }
    }
  }

  /**
   * Tests that messages for each category are restricted to a single
   * messages file and that each file only contains messages from a
   * single category.
   */
  @Test
  public void testCategoriesDontSpanFiles() {
    Map<Category,Class> categoriesToClass = new HashMap<Category,Class>();
    Set categories = EnumSet.allOf(Category.class);
    Set<Class> msgClasses = MessageDescriptorRegistry.getRegisteredClasses();
    for (Class msgClass : msgClasses) {
      List<MessageDescriptor> mds =
              MessageDescriptorRegistry.getMessageDescriptorsForClass(msgClass);
      Category currentCategory = null;
      for (MessageDescriptor md : mds) {
        if (currentCategory == null) {
          currentCategory = md.getCategory();
          if (categories.contains(currentCategory)) {
            categories.remove(currentCategory);
            categoriesToClass.put(currentCategory, msgClass);
          } else {
            assertTrue(false,
                    "Message file " + msgClass + " defines descriptors " +
                    "for category " + currentCategory + " but message file " +
                    categoriesToClass.get(currentCategory) + " defines descriptors " +
                    "of " + currentCategory + ".  Descriptors for a particular " +
                    "category can only be defined in a single messages file.");
          }
        } else {
          boolean categoriesMatch = currentCategory.equals(md.getCategory());
          assertTrue(categoriesMatch,
                  "Message file " + msgClass + " contains descriptors from at least " +
                          "two different categories: descriptor of key " +
                          md.getFormatString() + " is of category " + md.getCategory() +
                          " but expected category was " + currentCategory);

        }
      }
    }
  }
}