SsoProcessException exception2 = new SsoProcessException("Test");

        // Both instances should be of the same class
        assertEquals(exception1.getClass(), exception2.getClass());
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "SSO configuration error";
        try {

    if (test instanceof AbstractTester) {
      AbstractTester<?> tester = (AbstractTester<?>) test;
      return getMethod(tester.getClass(), tester.getTestMethodName());
    } else if (test instanceof TestCase) {
      TestCase testCase = (TestCase) test;
      return getMethod(testCase.getClass(), testCase.getName());
    } else {
      throw new IllegalArgumentException("unable to extract method from test: not a TestCase.");
    }

    }

    // Helper methods for reflection
    private void setFieldValue(Object obj, String fieldName, Object value) {
        try {
            Field field = findField(obj.getClass(), fieldName);
            field.setAccessible(true);
            field.set(obj, value);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set field " + fieldName, e);
        }

            return "";
        }
        final StringBuilder buf = new StringBuilder(100);
        for (final Object arg : methodArgs) {
            if (arg != null) {
                buf.append(arg.getClass().getName());
            } else {
                buf.append("null");
            }
            buf.append(", ");
        }
        buf.setLength(buf.length() - 2);
        return new String(buf);
    }

        if (this == obj) {
            return true;
        }

        if (obj == null) {
            return false;
        }

        if (!FileSource.class.equals(obj.getClass())) {
            return false;
        }

        FileSource other = (FileSource) obj;
        return this.path.equals(other.path);
    }

   * the time this method is called.
   */
  Iterator<Subscriber> getSubscribers(Object event) {
    ImmutableSet<Class<?>> eventTypes = flattenHierarchy(event.getClass());

    List<Iterator<Subscriber>> subscriberIterators =
        Lists.newArrayListWithCapacity(eventTypes.size());

    for (Class<?> eventType : eventTypes) {

    if (test instanceof AbstractTester) {
      AbstractTester<?> tester = (AbstractTester<?>) test;
      return getMethod(tester.getClass(), tester.getTestMethodName());
    } else if (test instanceof TestCase) {
      TestCase testCase = (TestCase) test;
      return getMethod(testCase.getClass(), testCase.getName());
    } else {
      throw new IllegalArgumentException("unable to extract method from test: not a TestCase.");
    }

      } catch (Throwable t) {
        threadUnexpectedException(t);
        return null;
      }
    }
  }

  <T> T serialClone(T o) {
    T clone = reserialize(o);
    assertThat(clone.getClass()).isEqualTo(o.getClass());
    return clone;
  }

        protected void setFieldValue(String fieldName, Object value) {
            try {
                Field field = null;
                Class<?> clazz = this.getClass();
                while (clazz != null && field == null) {
                    try {
                        field = clazz.getDeclaredField(fieldName);
                    } catch (NoSuchFieldException e) {

     */
    public void setDefault(Object bean, Object defaultValue, PlexusConfiguration configuration)
            throws ComponentConfigurationException {

        Class<?> beanType = bean.getClass();

        // Find the default "set" method
        MethodInfo setterInfo = findCachedMethod(beanType, "", null);
        if (setterInfo == null) {
            // Look for any method named "set" with one parameter