public void testInjectionEntries() throws Exception {
    JaninoMeta meta = populateJaninoMeta();
    List<StepInjectionMetaEntry> entries =
        meta.getStepMetaInjectionInterface().getStepInjectionMetadataEntries();
    assertEquals(1, entries.size());

    StepInjectionMetaEntry fieldsEntry =
        StepInjectionUtil.findEntry(entries, JaninoMetaInjection.Entry.EXPRESSION_FIELDS);
    assertNotNull(fieldsEntry);
    StepInjectionMetaEntry fieldEntry =
        StepInjectionUtil.findEntry(
            fieldsEntry.getDetails(), JaninoMetaInjection.Entry.EXPRESSION_FIELD);
    assertNotNull(fieldEntry);
    assertNotNull(
        StepInjectionUtil.findEntry(
            fieldEntry.getDetails(), JaninoMetaInjection.Entry.NEW_FIELDNAME));
    assertNotNull(
        StepInjectionUtil.findEntry(
            fieldEntry.getDetails(), JaninoMetaInjection.Entry.JAVA_EXPRESSION));
    assertNotNull(
        StepInjectionUtil.findEntry(fieldEntry.getDetails(), JaninoMetaInjection.Entry.VALUE_TYPE));
    assertNotNull(
        StepInjectionUtil.findEntry(fieldEntry.getDetails(), JaninoMetaInjection.Entry.LENGTH));
    assertNotNull(
        StepInjectionUtil.findEntry(fieldEntry.getDetails(), JaninoMetaInjection.Entry.PRECISION));
    assertNotNull(
        StepInjectionUtil.findEntry(
            fieldEntry.getDetails(), JaninoMetaInjection.Entry.REPLACE_VALUE));
  }
  private JaninoMeta populateJaninoMeta() {
    JaninoMeta meta = new JaninoMeta();
    meta.allocate(NR_FIELDS);

    // CHECKSTYLE:Indentation:OFF
    for (int i = 0; i < NR_FIELDS; i++) {
      meta.getFormula()[i] =
          new JaninoMetaFunction(
              NEW_FIELDNAME + i,
              JAVA_EXPRESSION + i,
              ValueMetaFactory.getIdForValueMeta(VALUE_TYPE),
              LENGTH + i,
              PRECISION + i,
              REPLACE_VALUE + i);
    }

    return meta;
  }
  public void testInjectionExtraction() throws Exception {

    // Test Strategy :
    //
    // Populate a new object, extract the metadata,
    // then inject into another set of metadata, compare the results.
    //
    JaninoMeta meta = populateJaninoMeta();

    List<StepInjectionMetaEntry> entries = meta.extractStepMetadataEntries();

    assertEquals(1, entries.size());

    JaninoMeta newMeta = new JaninoMeta();
    newMeta.getStepMetaInjectionInterface().injectStepMetadataEntries(entries);

    // Automatic compare
    //
    List<StepInjectionMetaEntry> cmpEntries = newMeta.extractStepMetadataEntries();
    StepInjectionUtil.compareEntryValues(entries, cmpEntries);
  }
  /** Test case for janino step. */
  public void testJaninoStep() throws Exception {
    KettleEnvironment.init();

    //
    // Create a new transformation...
    //
    TransMeta transMeta = new TransMeta();
    transMeta.setName("janino test");

    PluginRegistry registry = PluginRegistry.getInstance();

    // create an injector step...
    String injectorStepName = "injector step";
    InjectorMeta im = new InjectorMeta();

    // Set the information of the injector.
    String injectorPid = registry.getPluginId(StepPluginType.class, im);
    StepMeta injectorStep = new StepMeta(injectorPid, injectorStepName, im);
    transMeta.addStep(injectorStep);

    //
    // create a janino step...
    //
    String stepname = "janino";
    JaninoMeta jm = new JaninoMeta();

    // Set the information of the step
    String janinoPid = registry.getPluginId(StepPluginType.class, jm);
    StepMeta janinoStep = new StepMeta(janinoPid, stepname, jm);
    transMeta.addStep(janinoStep);

    jm.setDefault();

    JaninoMetaFunction[] formulas = {
      new JaninoMetaFunction(
          "string",
          "(string==null)?null:\"string-value\"",
          ValueMeta.TYPE_STRING,
          -1,
          -1,
          "string"),
      new JaninoMetaFunction(
          "integer",
          "(integer==null)?null:new Long(42L)",
          ValueMeta.TYPE_INTEGER,
          -1,
          -1,
          "integer"),
      new JaninoMetaFunction(
          "number",
          "(number==null)?null:new Double(23.0)",
          ValueMeta.TYPE_NUMBER,
          -1,
          -1,
          "number"),
      new JaninoMetaFunction(
          "bigdecimal",
          "(bigdecimal==null)?null:new java.math.BigDecimal(11.0)",
          ValueMeta.TYPE_BIGNUMBER,
          -1,
          -1,
          "bigdecimal"),
      new JaninoMetaFunction(
          "date",
          "(date==null)?null:new java.util.Date(10000000)",
          ValueMeta.TYPE_DATE,
          -1,
          -1,
          "date"),
      new JaninoMetaFunction(
          "binary",
          "(binary==null)?null:new byte[]{1,2,3,4,5}",
          ValueMeta.TYPE_BINARY,
          -1,
          -1,
          "binary"),
      new JaninoMetaFunction(
          "bool", "(bool==null)?null:Boolean.TRUE", ValueMeta.TYPE_BOOLEAN, -1, -1, "bool"),
    };

    jm.setFormula(formulas);

    transMeta.addTransHop(new TransHopMeta(injectorStep, janinoStep));

    //
    // Create a dummy step
    //
    String dummyStepname = "dummy step";
    DummyTransMeta dm = new DummyTransMeta();

    String dummyPid = registry.getPluginId(StepPluginType.class, dm);
    StepMeta dummyStep = new StepMeta(dummyPid, dummyStepname, dm);
    transMeta.addStep(dummyStep);

    TransHopMeta hi = new TransHopMeta(janinoStep, dummyStep);
    transMeta.addTransHop(hi);

    // Now execute the transformation...
    Trans trans = new Trans(transMeta);

    trans.prepareExecution(null);

    StepInterface si = trans.getStepInterface(dummyStepname, 0);
    RowStepCollector rc = new RowStepCollector();
    si.addRowListener(rc);
    RowProducer rp = trans.addRowProducer(injectorStepName, 0);

    trans.startThreads();

    for (RowMetaAndData rm : createInputList()) {
      rp.putRow(rm.getRowMeta(), rm.getData());
    }
    rp.finished();

    trans.waitUntilFinished();

    List<RowMetaAndData> checkList = createExpectedList();
    List<RowMetaAndData> resultRows = rc.getRowsWritten();
    checkRows(resultRows, checkList);
  }