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

Common ways to obtain Parameterized$Parameter

private void myMethod () {
 Parameterized$Parameter p =Field field;field.getAnnotation(Parameter.class)
Smart code suggestions by Tabnine
}

@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() != 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;
}

/**
 * @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() != 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;
}

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

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;
}

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() != 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();
    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;
}

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;
}

Popular methods of Parameterized$Parameter

<init>

Popular in Java

Start an intent from android
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
notifyDataSetChanged (ArrayAdapter)
getApplicationContext (Context)
GridBagLayout (java.awt)
The GridBagLayout class is a flexible layout manager that aligns components vertically and horizonta
MessageDigest (java.security)
Uses a one-way hash function to turn an arbitrary number of bytes into a fixed-length byte sequence.
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
ResourceBundle (java.util)
ResourceBundle is an abstract class which is the superclass of classes which provide Locale-specifi
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled

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