assertArgumentNotNull("clazz", clazz);

        try {
            return clazz.newInstance();
        } catch (final InstantiationException e) {
            throw new InstantiationRuntimeException(clazz, e);
        } catch (final IllegalAccessException e) {
            throw new IllegalAccessRuntimeException(clazz, e);
        }
    }

    /**

            try {
                fileAuthenticationService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

        getRequestHeader(form).ifPresent(entity -> {
            try {
                requestHeaderService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

        StringWriter sWriter = new StringWriter(1024);

        MavenStaxWriter writer = new MavenStaxWriter();
        try {
            writer.write(sWriter, model.getDelegate());
        } catch (IOException | XMLStreamException e) {
            throw new ModelInterpolationException("Cannot serialize project model for interpolation.", e);
        }

        String serializedModel = sWriter.toString();

        getDataConfig(form).ifPresent(entity -> {
            try {
                dataConfigService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

      Class<T> interfaceType,
      Function<T, ? extends T> wrapperFunction,
      String... expectedMessages) {
    try {
      tester.testForwarding(interfaceType, wrapperFunction);
    } catch (AssertionFailedError expected) {
      for (String message : expectedMessages) {
        assertThat(expected.getMessage()).contains(message);
      }
      return;
    }
    fail("expected failure not reported");

            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }
        }
        return DfTypeUtil.toLocalDateTime(value);
    }

    @SuppressWarnings("unchecked")

        multiExceptionListIterator.promoteToNext(targetReturnValueFromNext);
      }

      referenceReturnValue = method.execute(reference);
    } catch (PermittedMetaException e) {
      referenceException = e;
    } catch (UnknownElementException e) {
      throw new AssertionError(e);
    }

    if (referenceException == null) {
      if (targetException != null) {

      assertFalse(getMap().entrySet().contains(mapEntry(IncomparableType.INSTANCE, v0())));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

  public void testContainsEntryWithIncomparableValue() {
    try {
      assertFalse(getMap().entrySet().contains(mapEntry(k0(), IncomparableType.INSTANCE)));
    } catch (ClassCastException acceptable) {
      // allowed by the spec
    }
  }

                        populate(r, tc);
                    }
                }
                result = this.table.get(name);
            }
        }
        catch ( IOException fnfe ) {
            log.error("Could not read lmhosts " + tc.getConfig().getLmHostsFileName(), fnfe); //$NON-NLS-1$
        }
        return result;
    }