org.junit.runners.Parameterized$Parameter.value java code examples

@Override
protected void validateFields(List<Throwable> errors) {
  super.validateFields(errors);
  if (fieldsAreAnnotated()) {
    List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
    int[] usedIndices = new int[annotatedFieldsByParameter.size()];
    for (FrameworkField each : annotatedFieldsByParameter) {
      int index = each.getField().getAnnotation(Parameter.class).value();
      if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
        errors.add(
            new Exception("Invalid @Parameter value: " + index + ". @Parameter fields counted: " +
                annotatedFieldsByParameter.size() + ". Please use an index between 0 and " +
                (annotatedFieldsByParameter.size() - 1) + ".")
        );
      } else {
        usedIndices[index]++;
      }
    }
    for (int index = 0; index < usedIndices.length; index++) {
      int numberOfUse = usedIndices[index];
      if (numberOfUse == 0) {
        errors.add(new Exception("@Parameter(" + index + ") is never used."));
      } else if (numberOfUse > 1) {
        errors.add(new Exception("@Parameter(" + index + ") is used more than once (" + numberOfUse + ")."));
      }
    }
  }
}

@Override
protected void validateFields(List<Throwable> errors) {
  super.validateFields(errors);
  if (fieldsAreAnnotated()) {
    List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
    int[] usedIndices = new int[annotatedFieldsByParameter.size()];
    for (FrameworkField each : annotatedFieldsByParameter) {
      int index = each.getField().getAnnotation(Parameterized.Parameter.class).value();
      if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
        errors.add(
            new Exception("Invalid @Parameter value: " + index + ". @Parameter fields counted: " +
                annotatedFieldsByParameter.size() + ". Please use an index between 0 and " +
                (annotatedFieldsByParameter.size() - 1) + ".")
        );
      }
      else {
        usedIndices[index]++;
      }
    }
    for (int index = 0; index < usedIndices.length; index++) {
      int numberOfUse = usedIndices[index];
      if (numberOfUse == 0) {
        errors.add(new Exception("@Parameter(" + index + ") is never used."));
      }
      else if (numberOfUse > 1) {
        errors.add(new Exception("@Parameter(" + index + ") is used more than once (" + numberOfUse + ")."));
      }
    }
  }
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields." +
        " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    } catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
          " with the value " + fParameters[index] +
          " that is not the right type (" + fParameters[index].getClass().getSimpleName() + " instead of " +
          field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + parameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + parameters[index] + " that is not the right type ("
        + parameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception(
        "Wrong number of parameters and @Parameter fields."
            + " @Parameter fields counted: "
            + annotatedFieldsByParameter.size()
            + ", available parameters: " + parameters.length
            + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    } catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName()
          + ": Trying to set " + field.getName()
          + " with the value " + parameters[index]
          + " that is not the right type ("
          + parameters[index].getClass().getSimpleName()
          + " instead of " + field.getType().getSimpleName()
          + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + fParameters[index] + " that is not the right type ("
        + fParameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + parameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + parameters[index] + " that is not the right type ("
        + parameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + fParameters[index] + " that is not the right type ("
        + fParameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + parameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + parameters[index] + " that is not the right type ("
        + parameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + parameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + parameters[index] + " that is not the right type ("
        + parameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

/**
 * @see BlockJUnit4ClassRunnerWithParameters#createTestUsingFieldInjection()
 */
private static Object createTestUsingFieldInjection(TestClass testClass, Object[] parameters) throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter(testClass);
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields." + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
        + ", available parameters: " + parameters.length + ".");
  }
  Object testClassInstance = testClass.getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameterized.Parameter annotation = field.getAnnotation(Parameterized.Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    } catch (IllegalArgumentException iare) {
      throw new Exception(
          testClass.getName() + ": Trying to set " + field.getName() + " with the value " + parameters[index] + " that is not the right type ("
              + parameters[index].getClass().getSimpleName() + " instead of " + field.getType().getSimpleName() + ").",
          iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields." +
        " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    } catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
          " with the value " + fParameters[index] +
          " that is not the right type (" + fParameters[index].getClass().getSimpleName() + " instead of " +
          field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields." +
        " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    } catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
          " with the value " + fParameters[index] +
          " that is not the right type (" + fParameters[index].getClass().getSimpleName() + " instead of " +
          field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

@Override
protected void validateFields(List<Throwable> errors) {
  super.validateFields(errors);
  if (fieldsAreAnnotated()) {
    List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
    int[] usedIndices = new int[annotatedFieldsByParameter.size()];
    for (FrameworkField each : annotatedFieldsByParameter) {
      int index = each.getField().getAnnotation(Parameter.class).value();
      if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
        errors.add(new Exception("Invalid @Parameter value: " + index
          + ". @Parameter fields counted: " + annotatedFieldsByParameter.size()
          + ". Please use an index between 0 and "
          + (annotatedFieldsByParameter.size() - 1) + "."));
      }
      else {
        usedIndices[index]++;
      }
    }
    for (int index = 0; index < usedIndices.length; index++) {
      int numberOfUse = usedIndices[index];
      if (numberOfUse == 0) {
        errors.add(new Exception("@Parameter(" + index + ") is never used."));
      }
      else if (numberOfUse > 1) {
        errors.add(new Exception("@Parameter(" + index + ") is used more than once ("
          + numberOfUse + ")."));
      }
    }
  }
}

@Override
protected void validateFields(List<Throwable> errors) {
  super.validateFields(errors);
  if (fieldsAreAnnotated()) {
    List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
    int[] usedIndices = new int[annotatedFieldsByParameter.size()];
    for (FrameworkField each : annotatedFieldsByParameter) {
      int index = each.getField().getAnnotation(Parameter.class).value();
      if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
        errors.add(
            new Exception("Invalid @Parameter value: " + index + ". @Parameter fields counted: " +
                annotatedFieldsByParameter.size() + ". Please use an index between 0 and " +
                (annotatedFieldsByParameter.size() - 1) + ".")
        );
      } else {
        usedIndices[index]++;
      }
    }
    for (int index = 0; index < usedIndices.length; index++) {
      int numberOfUse = usedIndices[index];
      if (numberOfUse == 0) {
        errors.add(new Exception("@Parameter(" + index + ") is never used."));
      } else if (numberOfUse > 1) {
        errors.add(new Exception("@Parameter(" + index + ") is used more than once (" + numberOfUse + ")."));
      }
    }
  }
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields."
      + " @Parameter fields counted: " + annotatedFieldsByParameter.size()
      + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName()
        + " with the value " + fParameters[index] + " that is not the right type ("
        + fParameters[index].getClass().getSimpleName() + " instead of "
        + field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != fParameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields." +
        " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + fParameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameter annotation = field.getAnnotation(Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, fParameters[index]);
    } catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
          " with the value " + fParameters[index] +
          " that is not the right type (" + fParameters[index].getClass().getSimpleName() + " instead of " +
          field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

Field field = each.getField();
Parameter annotation = field.getAnnotation(Parameter.class);
int index = annotation.value();
try {
  field.set(testClassInstance, parameters[index]);

for (FrameworkField each : annotatedFieldsByParameter) {
  int index = each.getField().getAnnotation(Parameter.class)
      .value();
  if (index < 0 || index > annotatedFieldsByParameter.size() - 1) {
    errors.add(new Exception("Invalid @Parameter value: "

private Object createTestUsingFieldInjection() throws Exception {
  List<FrameworkField> annotatedFieldsByParameter = getAnnotatedFieldsByParameter();
  if (annotatedFieldsByParameter.size() != parameters.length) {
    throw new Exception("Wrong number of parameters and @Parameter fields." +
        " @Parameter fields counted: " + annotatedFieldsByParameter.size() + ", available parameters: " + parameters.length + ".");
  }
  Object testClassInstance = getTestClass().getJavaClass().newInstance();
  for (FrameworkField each : annotatedFieldsByParameter) {
    Field field = each.getField();
    Parameterized.Parameter annotation = field.getAnnotation(Parameterized.Parameter.class);
    int index = annotation.value();
    try {
      field.set(testClassInstance, parameters[index]);
    }
    catch (IllegalArgumentException iare) {
      throw new Exception(getTestClass().getName() + ": Trying to set " + field.getName() +
          " with the value " + parameters[index] +
          " that is not the right type (" + parameters[index].getClass().getSimpleName() + " instead of " +
          field.getType().getSimpleName() + ").", iare);
    }
  }
  return testClassInstance;
}

Popular methods of Parameterized$Parameter

<init>

Popular in Java

Running tasks concurrently on multiple threads
getSharedPreferences (Context)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
scheduleAtFixedRate (Timer)
FileOutputStream (java.io)
An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
FileWriter (java.io)
A specialized Writer that writes to a file in the file system. All write requests made by calling me
OutputStream (java.io)
A writable sink for bytes.Most clients will use output streams that write data to the file system (
DateFormat (java.text)
Formats or parses dates and times.This class provides factories for obtaining instances configured f
NumberFormat (java.text)
The abstract base class for all number formats. This class provides the interface for formatting and
SimpleDateFormat (java.text)
Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
14 Best Plugins for Eclipse

How to use valuemethodin org.junit.runners.Parameterized$Parameter

Best Java code snippets using org.junit.runners.Parameterized$Parameter.value (Showing top 20 results out of 315)

How to use
value
method
in
org.junit.runners.Parameterized$Parameter