org.kie.dmn.core.util.DMNRuntimeUtil.createRuntimeWithAdditionalResources java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 ArrayList a =new ArrayList<String>()
new ArrayList()
new ArrayList<Object>()
Smart code suggestions by Tabnine
}

@Test
public void testImportTransitiveBaseModel() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Sayhello1ID1D.dmn",
                                          this.getClass(),
                                          "ModelB.dmn",
                                          "ModelB2.dmn",
                                          "ModelC.dmn");
  getAndAssertModelNoErrors(runtime, "http://www.trisotech.com/dmn/definitions/_ae5b3c17-1ac3-4e1d-b4f9-2cf861aec6d9", "Say hello 1ID1D");
}

@Test
public void testInvalidFunction() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources( "InvalidFunction.dmn", this.getClass() );
  final DMNModel model = runtime.getModel( "http://www.trisotech.com/definitions/_84453b71-5d23-479f-9481-5196d92bacae", "0003-iteration-augmented" );
  assertThat( model, notNullValue() );
  final DMNContext context = DMNFactory.newContext();
  context.set( "Loans", new HashMap<>() );
  final DMNResult result = runtime.evaluateAll(model, context);
  final List<DMNDecisionResult> decisionResults = result.getDecisionResults();
  FEELStringMarshaller.INSTANCE.marshall( Arrays.asList(decisionResults.get(0).getResult(), decisionResults.get(1).getResult()) );
}

@Test
public void testImportDS() {
  // DROOLS-2768 DMN Decision Service encapsulate Decision which imports a Decision Service
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("DecisionService20180718.dmn", this.getClass(), "ImportDecisionService20180718.dmn");
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_0ff3708a-c861-4a96-b85c-7b882f18b7a1", "Import Decision Service 20180718");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  testImportDS_testEvaluateAll(runtime, dmnModel);
  testImportDS_testEvaluateDS(runtime, dmnModel);
}

@BeforeClass
public static void setup() {
  runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Two-Value Logic Tests.dmn",
      DMNTwoValueLogicTest.class,
      "/libs/Two-Value Logic.dmn");
  dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_0062b41c-61d2-43db-a575-676ed3c6d967",
      "Two-Value Logic Tests");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  context = DMNFactory.newContext();
}

@Test
public void testDecisionService20180920() {
  // DROOLS-3005 DMN DecisionService having an imported requiredInput
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("DSWithImportRequiredInput20180920.dmn",
                                          this.getClass(),
                                          "DSWithImportRequiredInput20180920-import-1.dmn");
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_76165d7d-12f8-46d3-b8af-120f1ac8b3fc", "Model B");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  testDecisionService20180920_testEvaluateAll(runtime, dmnModel);
  testDecisionService20180920_testEvaluateDS(runtime, dmnModel);
}

@Test
public void testTransitiveImportDS() {
  // DROOLS-2768 DMN Decision Service encapsulate Decision which imports a Decision Service   
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("DecisionService20180718.dmn", this.getClass(),
                                          "ImportDecisionService20180718.dmn",
                                          "ImportofImportDecisionService20180718.dmn");
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_6698dc07-cc43-47ec-8187-8faa7d8c35ba", "Import of Import Decision Service 20180718");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  testTransitiveImportDS_testEvaluateAll(runtime, dmnModel);
  testTransitiveImportDS_testEvaluateDS(runtime, dmnModel);
}

@Test
public void testAllowDMNAPItoEvaluateDirectDependencyImportedDecisions() {
  // DROOLS-3012 Allow DMN API to evaluate direct-dependency imported Decisions
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Sayhello1ID1D.dmn",
                                          this.getClass(),
                                          "ModelB.dmn");
  final DMNModel dmnModel = getAndAssertModelNoErrors(runtime, "http://www.trisotech.com/dmn/definitions/_2a1d771a-a899-4fef-abd6-fc894332337c", "Model B");
  
  testAllowDMNAPItoEvaluateDirectDependencyImportedDecisions_evaluateResultsAndCheck(runtime,
                                            context -> runtime.evaluateByName(dmnModel,
                                                             context,
                                                             "modelA.Greet the Person",
                                                             "Evaluating Say Hello"));
  testAllowDMNAPItoEvaluateDirectDependencyImportedDecisions_evaluateResultsAndCheck(runtime,
                                            context -> runtime.evaluateById(dmnModel,
                                                            context,
                                                            "http://www.trisotech.com/dmn/definitions/_ae5b3c17-1ac3-4e1d-b4f9-2cf861aec6d9#_f7fdaec4-d669-4797-b3b4-12b860de2eb5",
                                                            "_96df766e-23e1-4aa6-9d5d-545fbe2f1e23"));
}

@Ignore
@Test
public void testBaseModel_OK() {
  DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("import/Base-model.dmn", this.getClass(), "import/Import-base-model.dmn");
  DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_b33fa7d9-f501-423b-afa8-15ded7e7f493", "Import base model");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  DMNContext context = DMNFactory.newContext();
  context.set("Customer", mapOf(entry("full name", "John Doe"), entry("age", 47)));
  DMNResult dmnResult = runtime.evaluateAll(dmnModel, context);
  LOG.debug("{}", dmnResult);
  assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));
}

@Test
public void testImportTransitiveEvaluate2Layers() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Sayhello1ID1D.dmn",
                                          this.getClass(),
                                          "ModelB.dmn",
                                          "ModelB2.dmn",
                                          "ModelC.dmn");
  final DMNModel dmnModel = getAndAssertModelNoErrors(runtime, "http://www.trisotech.com/dmn/definitions/_2a1d771a-a899-4fef-abd6-fc894332337c", "Model B");
  final DMNContext context = runtime.newContext();
  context.set("modelA", mapOf(entry("Person name", "John")));
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  LOG.debug("{}", evaluateAll);
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  assertThat(evaluateAll.getDecisionResultByName("Evaluating Say Hello").getResult(), is("Evaluating Say Hello to: Hello, John"));
}

@Test
public void testImportingID() {
  // DROOLS-2944 DMN decision logic referencing DMN<import> InputData
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Sayhello1ID1D.dmn",
                                          this.getClass(),
                                          "Importing_ID.dmn");
  final DMNModel dmnModel = getAndAssertModelNoErrors(runtime, "http://www.trisotech.com/dmn/definitions/_24bac498-2a5a-403d-8b44-d407628784c4", "Importing ID");
  final DMNContext context = runtime.newContext();
  context.set("my import hello", mapOf(entry("Person name", "DROOLS-2944")));
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  LOG.debug("{}", evaluateAll);
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  assertThat(evaluateAll.getDecisionResultByName("Hello decision using imported InputData").getResult(), is("Hello, DROOLS-2944"));
}

@Test
public void testImportHardcodedDecisions() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Spell_Greeting.dmn",
                                          this.getClass(),
                                          "Import_Spell_Greeting.dmn");
  final DMNModel importedModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_88f4fc88-1eb2-4188-a721-5720cf5565ce",
                          "Spell Greeting");
  assertThat(importedModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(importedModel.getMessages()), importedModel.hasErrors(), is(false));
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_d67f19e9-7835-4cad-9c80-16b8423cc392",
                        "Import Spell Greeting");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  final DMNContext context = runtime.newContext();
  context.set("Person Name", "John");
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  LOG.debug("{}", evaluateAll);
  assertThat(evaluateAll.getDecisionResultByName("Say the Greeting to Person").getResult(), is("Hello, John"));
}

@Test
public void testRetrieveDecisionByIDName() {
  // DROOLS-3026
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Sayhello1ID1D.dmn",
                                          this.getClass(),
                                          "ModelB.dmn");
  final DMNModel dmnModel = getAndAssertModelNoErrors(runtime, "http://www.trisotech.com/dmn/definitions/_2a1d771a-a899-4fef-abd6-fc894332337c", "Model B");
  assertThat(dmnModel.getDecisionById("_96df766e-23e1-4aa6-9d5d-545fbe2f1e23").getName(), is("Evaluating Say Hello"));
  assertThat(dmnModel.getDecisionById("http://www.trisotech.com/dmn/definitions/_ae5b3c17-1ac3-4e1d-b4f9-2cf861aec6d9#_f7fdaec4-d669-4797-b3b4-12b860de2eb5").getName(), is("Greet the Person")); // this is an imported Decision
  assertThat(dmnModel.getDecisionById("_f7fdaec4-d669-4797-b3b4-12b860de2eb5"), nullValue()); // this is an imported Decision
  assertThat(dmnModel.getDecisionByName("Evaluating Say Hello").getId(), is("_96df766e-23e1-4aa6-9d5d-545fbe2f1e23"));
  assertThat(dmnModel.getDecisionByName("Greet the Person"), nullValue()); // this is an imported Decision
  assertThat(dmnModel.getDecisionByName("modelA.Greet the Person").getId(), is("_f7fdaec4-d669-4797-b3b4-12b860de2eb5")); // this is an imported Decision
  assertThat(dmnModel.getInputById("http://www.trisotech.com/dmn/definitions/_ae5b3c17-1ac3-4e1d-b4f9-2cf861aec6d9#_4f6c136c-8512-4d71-8bbf-7c9eb6e74063").getName(), is("Person name")); // this is an imported InputData node.
  assertThat(dmnModel.getInputById("_4f6c136c-8512-4d71-8bbf-7c9eb6e74063"), nullValue()); // this is an imported InputData node.
  assertThat(dmnModel.getInputByName("Person name"), nullValue()); // this is an imported InputData node.
  assertThat(dmnModel.getInputByName("modelA.Person name").getId(), is("_4f6c136c-8512-4d71-8bbf-7c9eb6e74063")); // this is an imported InputData node.
}

@Test
public void testDecisionTableInputClauseImportingItemDefinition() {
  // DROOLS-2927 DMN DecisionTable inputClause importing ItemDefinition throws NPE at compilation
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("imports/Imported_Model.dmn",
                                          this.getClass(),
                                          "imports/Importing_Person_DT_with_Person.dmn");
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_3d586cb1-3ed0-4bc4-a1a7-070b70ece398", "Importing Person DT with Person");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  final DMNContext context = DMNFactory.newContext();
  context.set("A Person here", mapOf(entry("age", new BigDecimal(17)),
                    entry("name", "John")));
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context);
  LOG.debug("{}", dmnResult);
  assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));
  final DMNContext result = dmnResult.getContext();
  assertThat(result.get("A Decision Table"), is("NOT Allowed"));
}

@Test
public void testImport2BKMsInvokeUsingInputData() {
  // DROOLS-2746 DMN Invocation parameters resolution with imported function
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Do_invoke_hello_with_2_bkms_using_inputdata.dmn",
                                          this.getClass(),
                                          "Saying_hello_2_bkms.dmn");
  final DMNModel importedModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_16a48e7a-0687-4c2d-b402-42925084fa1a",
                          "Saying hello 2 bkms");
  assertThat(importedModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(importedModel.getMessages()), importedModel.hasErrors(), is(false));
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_eedf6ecc-f113-4333-ace0-79b783e313e5",
                        "Do invoke hello with 2 bkms");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  final DMNContext context = runtime.newContext();
  context.set("Person name", "Bob");
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  LOG.debug("{}", evaluateAll);
  assertThat(evaluateAll.getDecisionResultByName("what about hello").getResult(), is("Hello, Bob"));
}

@Test
public void testImport2BKMs() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Do_say_hello_with_2_bkms.dmn",
                                          this.getClass(),
                                          "Saying_hello_2_bkms.dmn");
  final DMNModel importedModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_16a48e7a-0687-4c2d-b402-42925084fa1a",
                          "Saying hello 2 bkms");
  assertThat(importedModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(importedModel.getMessages()), importedModel.hasErrors(), is(false));
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_01a65215-7e0d-47ac-845a-a768f6abf7fe",
                        "Do say hello with 2 bkms");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  final DMNContext context = runtime.newContext();
  context.set("Person name", "John");
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  LOG.debug("{}", evaluateAll);
  assertThat(evaluateAll.getDecisionResultByName("Say hello decision").getResult(), is("Hello, John"));
  assertThat(evaluateAll.getDecisionResultByName("what about hello").getResult(), is("Hello"));
}

@Test
public void testInvokeFunctionWrongNamespace() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Caller.dmn", this.getClass(), "Calling.dmn" );
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_b0a696d6-3d57-4e97-b5d4-b44a63909d67", "Caller" );
  assertThat( dmnModel, notNullValue() );
  final DMNContext wrongContext = DMNFactory.newContext();
  wrongContext.set( "My Name", "John Doe" );
  wrongContext.set( "My Number", 3 );
  wrongContext.set("Call ns", "http://www.acme.com/a-wrong-namespace");
  wrongContext.set( "Call name", "Calling" );
  wrongContext.set( "Invoke decision", "Final Result" );
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, wrongContext );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( true ) );
  // total of: 2. x1 error in calling external decision, and x1 error in making final decision as it depends on the former.
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.getMessages().size(), is( 2 ) );
}

@Test
public void testInvokeFunctionWrongDecisionName() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Caller.dmn", this.getClass(), "Calling.dmn" );
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_b0a696d6-3d57-4e97-b5d4-b44a63909d67", "Caller" );
  assertThat( dmnModel, notNullValue() );
  final DMNContext wrongContext = DMNFactory.newContext();
  wrongContext.set( "My Name", "John Doe" );
  wrongContext.set( "My Number", 3 );
  wrongContext.set( "Call ns", "http://www.trisotech.com/definitions/_88156d21-3acc-43b6-8b81-385caf0bb6ca" );
  wrongContext.set( "Call name", "Calling" );
  wrongContext.set("Invoke decision", "<unexistent decision>");
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, wrongContext );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( true ) );
  // total of: 2. x1 error in calling external decision, and x1 error in making final decision as it depends on the former.
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.getMessages().size(), is( 2 ) );
}

@Test
public void testInvokeFunctionSuccess() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Caller.dmn", this.getClass(), "Calling.dmn" );
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_b0a696d6-3d57-4e97-b5d4-b44a63909d67", "Caller" );
  assertThat( dmnModel, notNullValue() );
  final DMNContext context = DMNFactory.newContext();
  context.set( "My Name", "John Doe" );
  context.set( "My Number", 3 );
  context.set( "Call ns", "http://www.trisotech.com/definitions/_88156d21-3acc-43b6-8b81-385caf0bb6ca" );
  context.set( "Call name", "Calling" );
  context.set( "Invoke decision", "Final Result" );
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( false ) );
    
  final DMNContext result = dmnResult.getContext();
  assertThat( result.get( "Final decision" ), is( "The final decision is: Hello, John Doe your number once double is equal to: 6" ) );
}

@Test
public void testInvokeFunctionCallerError() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Caller.dmn", this.getClass(), "Calling.dmn" );
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_b0a696d6-3d57-4e97-b5d4-b44a63909d67", "Caller" );
  assertThat( dmnModel, notNullValue() );
  final DMNContext wrongContext = DMNFactory.newContext();
  wrongContext.set( "My Name", "John Doe" );
  wrongContext.set("My Number", "<not a number>");
  wrongContext.set( "Call ns", "http://www.trisotech.com/definitions/_88156d21-3acc-43b6-8b81-385caf0bb6ca" );
  wrongContext.set( "Call name", "Calling" );
  wrongContext.set( "Invoke decision", "Final Result" );
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, wrongContext );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( true ) );
  // total of: 2. x1 error in calling external decision, and x1 error in making final decision as it depends on the former.
  // please notice it will print 4 lines in the log, 2x are the "external invocation" and then 2x are the one by the caller, checked herebelow:
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.getMessages().size(), is( 2 ) );
}

@Test
public void testImportTransitiveEvaluate3Layers() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Sayhello1ID1D.dmn",
                                          this.getClass(),
                                          "ModelB.dmn",
                                          "ModelB2.dmn",
                                          "ModelC.dmn");
  final DMNModel dmnModel = getAndAssertModelNoErrors(runtime, "http://www.trisotech.com/dmn/definitions/_10435dcd-8774-4575-a338-49dd554a0928", "Model C");
  final DMNContext context = runtime.newContext();
  context.set("Model B", mapOf(entry("modelA", mapOf(entry("Person name", "B.A.John")))));
  context.set("Model B2", mapOf(entry("modelA", mapOf(entry("Person name", "B2.A.John2")))));
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  LOG.debug("{}", evaluateAll);
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  assertThat(evaluateAll.getDecisionResultByName("Model C Decision based on Bs").getResult(), is("B: Evaluating Say Hello to: Hello, B.A.John; B2:Evaluating Say Hello to: Hello, B2.A.John2"));
}

Popular methods of DMNRuntimeUtil

Popular in Java

Reactive rest calls using spring rest template
getExternalFilesDir (Context)
setRequestProperty (URLConnection)
scheduleAtFixedRate (ScheduledExecutorService)
PrintStream (java.io)
Fake signature of an existing Java class.
Date (java.sql)
A class which can consume and produce dates in SQL Date format. Dates are represented in SQL as yyyy
GregorianCalendar (java.util)
GregorianCalendar is a concrete subclass of Calendarand provides the standard calendar used by most
Locale (java.util)
Locale represents a language/country/variant combination. Locales are used to alter the presentatio
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
SortedMap (java.util)
A map that has its keys ordered. The sorting is according to either the natural ordering of its keys
Top 17 Plugins for Android Studio

How to use createRuntimeWithAdditionalResourcesmethodin org.kie.dmn.core.util.DMNRuntimeUtil

Best Java code snippets using org.kie.dmn.core.util.DMNRuntimeUtil.createRuntimeWithAdditionalResources (Showing top 20 results out of 315)

How to use
createRuntimeWithAdditionalResources
method
in
org.kie.dmn.core.util.DMNRuntimeUtil