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

Creating JSON documents from java classes using gson
setScale (BigDecimal)
onCreateOptionsMenu (Activity)
getResourceAsStream (ClassLoader)
FileNotFoundException (java.io)
Thrown when a file specified by a program cannot be found.
String (java.lang)
ConnectException (java.net)
A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
URI (java.net)
A Uniform Resource Identifier that identifies an abstract or physical resource, as specified by RFC
Deque (java.util)
A linear collection that supports element insertion and removal at both ends. The name deque is shor
NoSuchElementException (java.util)
Thrown when trying to retrieve an element past the end of an Enumeration or Iterator.
Github Copilot alternatives

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