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

@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 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 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 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

Reading from database using SQL prepared statement
notifyDataSetChanged (ArrayAdapter)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
setContentView (Activity)
ObjectMapper (com.fasterxml.jackson.databind)
ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Pl
Color (java.awt)
The Color class is used to encapsulate colors in the default sRGB color space or colors in arbitrary
FileOutputStream (java.io)
An output stream that writes bytes to a file. If the output file exists, it can be replaced or appen
CountDownLatch (java.util.concurrent)
A synchronization aid that allows one or more threads to wait until a set of operations being perfor
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if
BoxLayout (javax.swing)
Top Sublime Text plugins

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