org.geotools.process.function.ProcessFunction Java Examples

@Override
List<List<LiteFeatureTypeStyle>> classifyByFeatureProduction(
    final List<LiteFeatureTypeStyle> lfts) {
  // strip off a distributed rendering render transform because that is
  // what is currently being processed
  final List<List<LiteFeatureTypeStyle>> retVal = super.classifyByFeatureProduction(lfts);
  for (final List<LiteFeatureTypeStyle> featureTypeStyles : retVal) {
    final LiteFeatureTypeStyle transformLfts = featureTypeStyles.get(0);
    // there doesn't seem to be an easy way to check if its a
    // distributed render transform so for now let's just not allow
    // other rendering transformations when distributed rendering is
    // employed and strip all transformations
    if (transformLfts.transformation instanceof ProcessFunction) {
      if ((((ProcessFunction) transformLfts.transformation).getName() != null)
          && ((ProcessFunction) transformLfts.transformation).getName().equals(
              DistributedRenderProcess.PROCESS_NAME)) {
        transformLfts.transformation = null;
      }
    }
  }
  return retVal;
}
 

/**
 * Test method for {@link
 * com.sldeditor.rendertransformation.RenderTransformationDialog#RenderTransformationDialog(com.sldeditor.common.connection.GeoServerConnectionManagerInterface)}.
 */
@Test
public void testRenderTransformationDialog() {
    TestRenderTransformationDialog testObj = new TestRenderTransformationDialog(null);

    testObj.test_internal_showDialog(null);
    ProcessFunction actualResult = testObj.getTransformationProcessFunction();
    assertNull(actualResult);

    ProcessFunctionFactory factory = new ProcessFunctionFactory();
    FunctionName functionName = factory.getFunctionNames().get(0);
    testObj.testDisplayFunction(functionName.getName());

    actualResult = testObj.getTransformationProcessFunction();
    assertNotNull(actualResult);
    testObj.test_internal_showDialog(actualResult);
}
 

/**
 * Populate parameter values.
 *
 * @param selectedProcessFunctionData the selected process function data
 * @param valueList the value list
 */
private void populateParameterValues(
        ProcessFunction selectedProcessFunctionData,
        List<ProcessFunctionParameterValue> valueList) {
    for (Expression parameter : selectedProcessFunctionData.getParameters()) {
        List<Expression> parameterList = ParameterFunctionUtils.getExpressionList(parameter);

        if ((parameterList != null) && !parameterList.isEmpty()) {
            Expression paramName = parameterList.get(0);

            ProcessFunctionParameterValue value =
                    findParameterValue(valueList, paramName.toString());

            if ((parameterList.size() > 1) && (value != null)) {
                Expression paramValue = parameterList.get(1);

                value.getObjectValue().setValue(paramValue);
                if (value.isOptional()) {
                    value.setIncluded(true);
                }
            }
        }
    }
}
 

/**
 * Extract parameters.
 *
 * @param functionName the function name
 * @param selectedProcessFunctionData the selected process function data
 * @return the list
 */
public List<ProcessFunctionParameterValue> extractParameters(
        FunctionName functionName, ProcessFunction selectedProcessFunctionData) {

    List<ProcessFunctionParameterValue> valueList = new ArrayList<>();

    // Populate the parameter definitions first.
    // This ensures if there is parameter data missing we
    // don't miss populating the parameter definition.
    if (functionName != null) {
        for (Parameter<?> parameter : functionName.getArguments()) {
            ProcessFunctionParameterValue value = new ProcessFunctionParameterValue();

            populateParameterDefinition(parameter, value);

            valueList.add(value);
        }
    }

    // Now populate any parameter values we have
    if (selectedProcessFunctionData != null) {
        populateParameterValues(selectedProcessFunctionData, valueList);
    }

    return valueList;
}
 

/**
 * Show transformation dialog.
 *
 * @param existingProcessFunction the existing process function
 * @return the process function
 */
private ProcessFunction showTransformationDialog(ProcessFunction existingProcessFunction) {
    ProcessFunction localProcessFunction = null;
    RenderTransformationDialog dlg =
            new RenderTransformationDialog(GeoServerConnectionManager.getInstance());

    if (dlg.showDialog(existingProcessFunction)) {
        localProcessFunction = dlg.getTransformationProcessFunction();
    }

    return localProcessFunction;
}
 

@Override
protected Expression copy(Expression expression) {
	if (expression instanceof ProcessFunction) {
		ProcessFunction f = (ProcessFunction) expression;
		return (ProcessFunction) CommonFactoryFinder.getFilterFactory2()
				.function(
						f.getProcessName(),
						f.getParameters().toArray(
								new Expression[f.getParameters().size()]));

	} else {
		return super.copy(expression);
	}
}
 

/**
 * Test method for {@link
 * com.sldeditor.rendertransformation.OptionalValueEditor#getCellEditorValue()}.
 */
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
void testGetCellEditorValue() {
    FunctionTableModel model = new FunctionTableModel();
    model.addNewValue(0);

    ProcessFunction processFunction = createProcessFunction();

    FunctionName name =
            new FunctionNameImpl(
                    "Test",
                    parameter("cellSize", Double.class),
                    new Parameter(
                            "outputBBOX", Number.class, null, null, false, 0, 100, null, null),
                    parameter("outputWidth", Number.class),
                    parameter("outputHeight", Number.class));

    assertFalse(name.getArguments().get(0).isRequired());
    assertTrue(name.getArguments().get(1).isRequired());

    model.populate(name, processFunction);

    TestOptionalValueEditor obj = new TestOptionalValueEditor(model);

    assertNotNull(obj.getTableCellEditorComponent(null, null, false, 0, 0));
    assertNotNull(obj.getCellEditorValue());
    obj.setValue();

    assertNull(obj.getTableCellEditorComponent(null, null, false, 1, 0));
}
 

/**
 * Test method for {@link
 * com.sldeditor.ui.detail.config.transform.FieldConfigTransformation#populateField(org.geotools.process.function.ProcessFunction)}.
 * Test method for {@link
 * com.sldeditor.ui.detail.config.transform.FieldConfigTransformation#populateField(java.lang.String)}.
 */
@Test
public void testPopulateFieldProcessFunction() {
    boolean valueOnly = true;
    TestFieldConfigTransformation field =
            new TestFieldConfigTransformation(
                    new FieldConfigCommonData(
                            String.class, FieldIdEnum.NAME, "test label", valueOnly, false),
                    "edit",
                    "clear");
    field.createUI();

    int undoListSize = UndoManager.getInstance().getUndoListSize();
    ProcessFunction processFunction = createProcessFunction();
    field.populateField(processFunction);
    field.transformationDialogResult(null);
    field.transformationDialogResult(processFunction);
    field.clearButtonPressed();
    assertEquals(undoListSize + 3, UndoManager.getInstance().getUndoListSize());

    // Suppress events
    field =
            new TestFieldConfigTransformation(
                    new FieldConfigCommonData(
                            String.class, FieldIdEnum.NAME, "test label", valueOnly, true),
                    "edit",
                    "clear");
    field.createUI();

    undoListSize = UndoManager.getInstance().getUndoListSize();
    field.populateField(processFunction);
    field.transformationDialogResult(null);
    field.transformationDialogResult(processFunction);
    field.clearButtonPressed();

    assertEquals(undoListSize, UndoManager.getInstance().getUndoListSize());
}
 

/**
 * Test method for {@link
 * com.sldeditor.ui.detail.config.transform.FieldConfigTransformation#populateExpression(java.lang.Object)}.
 * Test method for {@link
 * com.sldeditor.ui.detail.config.transform.FieldConfigTransformation#generateExpression()}.
 * Test method for {@link
 * com.sldeditor.ui.detail.config.transform.FieldConfigTransformation#getProcessFunction()}.
 */
@Test
public void testGenerateExpression() {
    boolean valueOnly = true;

    TestFieldConfigTransformation field =
            new TestFieldConfigTransformation(
                    new FieldConfigCommonData(
                            String.class, FieldIdEnum.NAME, "test label", valueOnly, false),
                    "edit",
                    "clear");
    Expression actualExpression = field.callGenerateExpression();
    assertNull(actualExpression);

    field.createUI();
    String expectedValue1 = "test string value";
    field.setTestValue(FieldIdEnum.UNKNOWN, expectedValue1);
    actualExpression = field.callGenerateExpression();
    assertNull(actualExpression);

    // Strings are ignored when calling populateExpression
    String expectedValue2 = "test string value as expression";
    field.populateExpression(expectedValue2);
    actualExpression = field.callGenerateExpression();
    assertNull(actualExpression);

    // Create process function
    ProcessFunction processFunction = createProcessFunction();
    field.populateExpression((ProcessFunction) null);
    field.populateExpression(processFunction);

    actualExpression = field.callGenerateExpression();
    String expectedValue3 = ParameterFunctionUtils.getString(processFunction);
    String string = actualExpression.toString();
    assertTrue(expectedValue3.compareTo(string) != 0);
    assertEquals(processFunction, field.getProcessFunction());
}
 

/**
 * Internal show dialog.
 *
 * @param existingProcessFunction the existing process function
 */
protected void internalShowDialog(ProcessFunction existingProcessFunction) {
    this.existingProcessFunction = existingProcessFunction;
    if (existingProcessFunction != null) {
        displayFunction(existingProcessFunction.getName());
    }
}
 

/**
 * Show dialog.
 *
 * @param existingProcessFunction the existing process function
 * @return true, if successful
 */
public boolean showDialog(ProcessFunction existingProcessFunction) {
    internalShowDialog(existingProcessFunction);
    setVisible(true);

    return okButtonPressed;
}
 

/**
 * Gets the expression.
 *
 * @param factory the factory
 * @return the expression
 */
public ProcessFunction getExpression(FunctionFactory factory) {
    if (factory == null) {
        return null;
    }

    List<Expression> overallParameterList = new ArrayList<>();

    for (ProcessFunctionParameterValue value : valueList) {
        List<Expression> parameterList = new ArrayList<>();
        parameterList.add(ff.literal(value.getName()));

        boolean setValue = true;
        if (value.isOptional()) {
            setValue = value.isIncluded();
        }

        if (setValue && (value.getObjectValue() != null)) {
            Expression expression = value.getObjectValue().getExpression();
            if (expression != null) {
                parameterList.add(expression);
            }
        }

        if (setValue) {
            Function function = factory.function(PARAMETER, parameterList, null);

            overallParameterList.add(function);
        }
    }

    if (this.selectedFunction.getFunctionName() == null) {
        return null;
    }
    Function processFunction =
            factory.function(
                    this.selectedFunction.getFunctionName(), overallParameterList, null);

    return (ProcessFunction) processFunction;
}
 

/**
 * Sets the built in process function.
 *
 * @param builtInProcessFunction the builtInProcessFunction to set
 * @param existingProcessFunction the existing process function
 */
public void setBuiltInProcessFunction(
        FunctionName builtInProcessFunction, ProcessFunction existingProcessFunction) {
    this.builtInProcessFunction = builtInProcessFunction;
    this.selectedProcessFunctionData = existingProcessFunction;
    this.selectedCustomFunction = null;
    this.builtInSelected = true;
}
 

/**
 * Gets the process function data as a string. Each parameter is on a new line.
 *
 * @param processFunction the process function
 * @return the string
 */
public static String getString(ProcessFunction processFunction) {
    StringBuilder sb = new StringBuilder();
    if (processFunction != null) {
        sb.append(processFunction.getFunctionName().toString());
        sb.append("(");
        int count = 0;
        for (Expression expression : processFunction.getParameters()) {
            if (count > 0) {
                sb.append(", ");
            }
            sb.append("\n  ");
            List<Expression> subParameterList = getExpressionList(expression);

            if ((subParameterList != null) && !subParameterList.isEmpty()) {
                if (subParameterList.size() == 1) {
                    sb.append(subParameterList.get(0).toString());
                    sb.append(PARAMETER_NOT_SET);
                } else if (subParameterList.size() == 2) {
                    sb.append(subParameterList.get(0).toString());
                    sb.append(":");
                    Expression expression2 = subParameterList.get(1);
                    if (expression2 != null) {
                        sb.append(expression2.toString());
                    } else {
                        sb.append(PARAMETER_NOT_SET);
                    }
                }
            }

            count++;
        }
        sb.append("\n)");
    }
    return sb.toString();
}
 

/**
 * Populate expression.
 *
 * @param objValue the obj value
 */
/*
 * (non-Javadoc)
 *
 * @see com.sldeditor.ui.detail.config.FieldConfigBase#populateExpression(java.lang.Object)
 */
@Override
public void populateExpression(Object objValue) {
    if (objValue instanceof ProcessFunction) {
        ProcessFunction localProcessFunction = (ProcessFunction) objValue;

        populateField(localProcessFunction);
    }
}
 

/**
 * Populate process function field.
 *
 * @param value the value
 */
@Override
public void populateField(ProcessFunction value) {
    processFunction = value;

    populateField(ParameterFunctionUtils.getString(processFunction));
}
 

/**
 * Populate process function.
 *
 * @param expression the expression
 */
private void populateProcessFunction(Expression expression) {
    ProcessFunction processExpression = (ProcessFunction) expression;

    Object objValue = processExpression;

    populateExpression(objValue);
}
 

/**
 * Populate.
 *
 * @param expression the expression
 */
public void populate(Expression expression) {
    if (attributeSelectionPanel != null) {
        attributeSelectionPanel.populateAttributeComboxBox(expression);
    }

    if (expression == null) {
        expressionType = ExpressionTypeEnum.E_VALUE;

        revertToDefaultValue();

        valueUpdated();
    } else {
        if (expression instanceof LiteralExpressionImpl) {
            populateLiteralExpression(expression);
        } else if (expression instanceof ConstantExpression) {
            populateConstantExpression(expression);
        } else if (expression instanceof NilExpression) {
            populateNilExpression();
        } else if (expression instanceof ProcessFunction) {
            populateProcessFunction(expression);
        } else if (expression instanceof AttributeExpressionImpl) {
            populateAttributeExpression(expression);
        } else if ((expression instanceof FunctionExpressionImpl)
                || (expression instanceof BinaryExpression)) {
            expressionType = ExpressionTypeEnum.E_EXPRESSION;

            if (attributeSelectionPanel != null) {
                attributeSelectionPanel.populate(expression);
            }

            setCachedExpression(expression);
        } else {
            expressionType = ExpressionTypeEnum.E_EXPRESSION;
        }
    }

    setValueFieldState();
}
 

/**
 * Test method for {@link
 * com.sldeditor.ui.detail.config.FieldConfigBase#populateField(java.lang.String)}.
 */
@Test
public void testPopulateFieldString() {
    FieldIdEnum expectedFieldId = FieldIdEnum.NAME;
    String expectedLabel = "test label";
    TestFieldConfigBase field =
            new TestFieldConfigBase(
                    new FieldConfigCommonData(
                            String.class, expectedFieldId, expectedLabel, false, false));

    field.populateField("");
    field.setTestValue(expectedFieldId, "");

    field.populateField(42);
    field.setTestValue(expectedFieldId, 42);
    assertEquals(0, field.getIntValue());

    field.populateField(3.142);
    field.setTestValue(expectedFieldId, 3.142);
    assertTrue(Math.abs(field.getDoubleValue()) < 0.0001);

    field.populateField(ZonedDateTime.now());
    field.populateField((ReferencedEnvelope) null);
    field.setTestValue(expectedFieldId, (ReferencedEnvelope) null);
    field.populateField((Id) null);
    field.populateField((TimePeriod) null);
    field.populateField((ProcessFunction) null);
    assertNull(field.getProcessFunction());

    field.populateField(true);
    field.setTestValue(expectedFieldId, true);
    assertEquals(false, field.getBooleanValue());

    field.populateField((ColorMap) null);
    field.setTestValue(expectedFieldId, (ColorMap) null);
    assertNull(field.getColourMap());

    field.populateField((List<FeatureTypeConstraint>) null);
    field.setTestValue(expectedFieldId, (List<FeatureTypeConstraint>) null);
    assertNull(field.getFeatureTypeConstraint());

    field.populateField((Font) null);
    assertNull(field.getFont());

    field.setTestValue(expectedFieldId, (Expression) null);

    assertNull(field.getEnumValue());
}
 

@Override
public Layer beforeLayer(final WMSMapContent mapContent, final Layer layer) {
  // sanity check the style
  if ((layer instanceof FeatureLayer)
      && (layer.getStyle() != null)
      && (layer.getStyle().featureTypeStyles() != null)
      && !layer.getStyle().featureTypeStyles().isEmpty()) {

    final Style layerStyle = layer.getStyle();
    final FeatureTypeStyle style = layerStyle.featureTypeStyles().get(0);
    // check if their is a DistributedRender rendering
    // transformation
    if ((style instanceof ProcessFunction)
        && (style.getTransformation() != null)
        && (((ProcessFunction) style.getTransformation()).getName() != null)
        && ((ProcessFunction) style.getTransformation()).getName().equals(
            DistributedRenderProcess.PROCESS_NAME)) {
      // if their is a DistributedRender transformation, we need
      // to provide more information that can only be found
      final DuplicatingStyleVisitor cloner = new DuplicatingStyleVisitor();
      layerStyle.accept(cloner);
      layer.getQuery().getHints().put(
          DistributedRenderProcess.OPTIONS,
          new DistributedRenderOptions(wms, mapContent, layerStyle));
      // now that the options with the distributed render style
      // have been set the original style will be used with
      // distributed rendering

      // now, replace the style with a direct raster symbolizer,
      // so the GridCoverage result of the distributed rendering
      // process is directly rendered to the map in place of the
      // original style

      final Style directRasterStyle = (Style) cloner.getCopy();
      directRasterStyle.featureTypeStyles().clear();
      Processors.addProcessFactory(new InternalProcessFactory());
      directRasterStyle.featureTypeStyles().add(
          getDirectRasterStyle(
              layer.getFeatureSource().getSchema().getGeometryDescriptor().getLocalName(),
              DistributedRenderProcessUtils.getRenderingProcess()));
      ((FeatureLayer) layer).setStyle(directRasterStyle);
    }
  }
  return layer;
}
 

/**
 * Test all the methods using a ProcessBriefType.
 *
 * <p>Not tested because it needs to interact with GeoServer to create a receive a remote custom
 * WPS function.
 */
@SuppressWarnings({"unchecked", "rawtypes"})
@Disabled
@Test
void testProcessBriefType() {
    FunctionTableModel model = new FunctionTableModel();

    assertEquals(0, model.getRowCount());

    model.addNewValue(0);
    ProcessBriefType customFunction = createCustomFunction();

    FunctionName name =
            new FunctionNameImpl(
                    new NameImpl("vec", "PointStacker"),
                    parameter("cellSize", Double.class),
                    new Parameter(
                            "outputBBOX", Number.class, null, null, false, 0, 100, null, null),
                    parameter("outputWidth", Number.class),
                    parameter("outputHeight", Number.class));

    assertFalse(name.getArguments().get(0).isRequired());
    assertTrue(name.getArguments().get(1).isRequired());

    model.populate(customFunction);

    assertEquals(3, model.getRowCount());
    assertEquals(4, model.getColumnCount());

    // Get value
    assertEquals("outputBBOX", model.getValueAt(0, 0));
    assertEquals(Number.class.getSimpleName(), model.getValueAt(0, 1));
    assertEquals(true, model.getValueAt(0, 2));
    assertEquals("env([wms_bbox])", model.getValueAt(0, 3));
    assertNull(model.getValueAt(0, 4));

    // Is editable
    assertFalse(model.isCellEditable(0, 0));
    assertFalse(model.isCellEditable(0, 1));
    assertTrue(model.isCellEditable(0, FunctionTableModel.getOptionalColumn()));
    assertFalse(model.isCellEditable(0, 3));
    assertFalse(model.isCellEditable(0, 4));

    // Set value
    model.setValueAt(true, 0, 2);
    assertTrue((Boolean) model.getValueAt(0, FunctionTableModel.getOptionalColumn()));
    model.setValueAt(false, 0, 2);
    assertFalse((Boolean) model.getValueAt(0, FunctionTableModel.getOptionalColumn()));

    // Get row
    assertNull(model.getValue(-1));
    assertNull(model.getValue(10));

    // Add a new value
    assertEquals(0, model.getNoOfOccurences(null));
    ProcessFunctionParameterValue value = model.getValue(0);
    assertEquals(1, model.getNoOfOccurences(value));
    model.addNewValue(0);
    assertEquals(4, model.getRowCount());

    assertEquals(2, model.getNoOfOccurences(value));

    // Remove value
    model.removeValue(3);
    assertEquals(3, model.getRowCount());

    // Get expression
    ProcessFunction actualFunction = model.getExpression(null);
    assertNull(actualFunction);

    model.setValueAt(true, 0, FunctionTableModel.getOptionalColumn());

    ProcessFunctionFactory factory = new ProcessFunctionFactory();
    actualFunction = model.getExpression(factory);
    assertNotNull(actualFunction);

    // Update expression
    FilterFactory ff = CommonFactoryFinder.getFilterFactory();

    Expression expression = ff.literal(4.2);
    model.update(expression, 0);
    model.update(null, 1);
}
 

/** Test all the methods using a ProcessFunction */
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
void testProcessFunction() {
    FunctionTableModel model = new FunctionTableModel();

    assertEquals(0, model.getRowCount());

    model.addNewValue(0);
    ProcessFunction processFunction = createProcessFunction();

    FunctionName name =
            new FunctionNameImpl(
                    new NameImpl("vec", "PointStacker"),
                    parameter("cellSize", Double.class),
                    new Parameter(
                            "outputBBOX", Number.class, null, null, false, 0, 100, null, null),
                    parameter("outputWidth", Number.class),
                    parameter("outputHeight", Number.class));

    assertFalse(name.getArguments().get(0).isRequired());
    assertTrue(name.getArguments().get(1).isRequired());

    model.populate(name, processFunction);

    assertEquals(3, model.getRowCount());
    assertEquals(4, model.getColumnCount());

    // Get value
    assertEquals("outputBBOX", model.getValueAt(0, 0));
    assertEquals(Number.class.getSimpleName(), model.getValueAt(0, 1));
    assertEquals(true, model.getValueAt(0, 2));
    assertEquals("env([wms_bbox])", model.getValueAt(0, 3));
    assertNull(model.getValueAt(0, 4));

    // Is editable
    assertFalse(model.isCellEditable(0, 0));
    assertFalse(model.isCellEditable(0, 1));
    assertTrue(model.isCellEditable(0, FunctionTableModel.getOptionalColumn()));
    assertFalse(model.isCellEditable(0, 3));
    assertFalse(model.isCellEditable(0, 4));

    // Set value
    model.setValueAt(true, 0, 2);
    assertTrue((Boolean) model.getValueAt(0, FunctionTableModel.getOptionalColumn()));
    model.setValueAt(false, 0, 2);
    assertFalse((Boolean) model.getValueAt(0, FunctionTableModel.getOptionalColumn()));

    // Get row
    assertNull(model.getValue(-1));
    assertNull(model.getValue(10));

    // Add a new value
    assertEquals(0, model.getNoOfOccurences(null));
    ProcessFunctionParameterValue value = model.getValue(0);
    assertEquals(1, model.getNoOfOccurences(value));
    model.addNewValue(0);
    assertEquals(4, model.getRowCount());

    assertEquals(2, model.getNoOfOccurences(value));

    // Remove value
    model.removeValue(3);
    assertEquals(3, model.getRowCount());

    // Get expression
    ProcessFunction actualFunction = model.getExpression(null);
    assertNull(actualFunction);

    model.setValueAt(true, 0, FunctionTableModel.getOptionalColumn());

    ProcessFunctionFactory factory = new ProcessFunctionFactory();
    actualFunction = model.getExpression(factory);
    assertNotNull(actualFunction);

    // Update expression
    FilterFactory ff = CommonFactoryFinder.getFilterFactory();

    Expression expression = ff.literal(4.2);
    model.update(expression, 0);
    model.update(null, 1);
}
 

/**
 * Test method for {@link
 * com.sldeditor.rendertransformation.CheckBoxRenderer#CheckBoxRenderer(com.sldeditor.rendertransformation.FunctionTableModel)}.
 */
@SuppressWarnings({"unchecked", "rawtypes"})
@Test
void testCheckBoxRenderer() {
    JTable table = new JTable();
    FunctionTableModel model = new FunctionTableModel();

    assertNull(
            new CheckBoxRenderer(null)
                    .getTableCellRendererComponent(null, null, false, false, 0, 0));

    assertNull(
            new CheckBoxRenderer(null)
                    .getTableCellRendererComponent(table, null, false, false, 0, 0));
    assertNull(
            new CheckBoxRenderer(model)
                    .getTableCellRendererComponent(null, null, false, false, 0, 0));

    model.addNewValue(0);

    ProcessFunction processFunction = createProcessFunction();

    FunctionName name =
            new FunctionNameImpl(
                    "Test",
                    parameter("cellSize", Double.class),
                    new Parameter(
                            "outputBBOX", Number.class, null, null, false, 0, 100, null, null),
                    parameter("outputWidth", Number.class),
                    parameter("outputHeight", Number.class));

    assertFalse(name.getArguments().get(0).isRequired());
    assertTrue(name.getArguments().get(1).isRequired());

    model.populate(name, processFunction);

    CheckBoxRenderer obj = new CheckBoxRenderer(model);

    // Row - optional and not selected
    assertEquals(obj, obj.getTableCellRendererComponent(table, null, false, false, 0, 0));
    assertEquals(obj, obj.getTableCellRendererComponent(table, true, false, false, 0, 0));
    assertTrue(obj.isSelected());
    assertEquals(obj, obj.getTableCellRendererComponent(table, false, false, false, 0, 0));
    assertFalse(obj.isSelected());

    // Row - optional and selected
    assertEquals(obj, obj.getTableCellRendererComponent(table, null, true, false, 0, 0));
    assertEquals(obj, obj.getTableCellRendererComponent(table, true, true, false, 0, 0));
    assertTrue(obj.isSelected());
    assertEquals(obj, obj.getTableCellRendererComponent(table, false, true, false, 0, 0));
    assertFalse(obj.isSelected());
    // Row - required and not selected
    assertEquals(
            JLabel.class,
            obj.getTableCellRendererComponent(table, null, false, false, 1, 0).getClass());
    // Row - required and selected
    assertEquals(
            JLabel.class,
            obj.getTableCellRendererComponent(table, null, true, false, 1, 0).getClass());
}
 

/**
 * Gets the process function, overridden if necessary.
 *
 * @return the process function
 */
@Override
public ProcessFunction getProcessFunction() {
    // Do nothing
    return null;
}
 

/**
 * Transformation dialog result.
 *
 * @param expression the expression
 */
protected void transformationDialogResult(ProcessFunction expression) {
    if (expression != null) {
        populateField(expression);
    }
}
 

@Override
protected void transformationDialogResult(ProcessFunction expression) {
    super.transformationDialogResult(expression);
}
 

/**
 * Gets the transformation process function.
 *
 * @return the transformation expression
 */
public ProcessFunction getTransformationProcessFunction() {
    return functionParameterTableModel.getExpression(factory);
}
 

/**
 * Gets the process function, overridden if necessary.
 *
 * @return the process function
 */
@Override
public ProcessFunction getProcessFunction() {
    return processFunction;
}
 

/**
 * Test internal show dialog.
 *
 * @param existingProcessFunction the existing process function
 */
public void test_internal_showDialog(ProcessFunction existingProcessFunction) {
    internalShowDialog(existingProcessFunction);
}
 

/**
 * Populate field.
 *
 * @param value the value
 */
public void populateField(ProcessFunction value);