Tabnine Logo
DMNRuntimeUtil.createRuntimeWithAdditionalResources
Code IndexAdd Tabnine to your IDE (free)

How to use
createRuntimeWithAdditionalResources
method
in
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)

origin: org.kie/kie-dmn-core

@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");
}
origin: org.kie/kie-dmn-core

@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()) );
}
origin: org.kie/kie-dmn-core

@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);
}
origin: org.kie/kie-dmn-core

@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();
}
origin: org.kie/kie-dmn-core

@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);
}
origin: org.kie/kie-dmn-core

@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);
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-validation

@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));
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-core

@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.
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-core

@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"));
}
origin: org.kie/kie-dmn-core

@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 ) );
}
origin: org.kie/kie-dmn-core

@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 ) );
}
origin: org.kie/kie-dmn-core

@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" ) );
}
origin: org.kie/kie-dmn-core

@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 ) );
}
origin: org.kie/kie-dmn-core

@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"));
}
org.kie.dmn.core.utilDMNRuntimeUtilcreateRuntimeWithAdditionalResources

Popular methods of DMNRuntimeUtil

  • createRuntime
  • formatMessages
  • createAndDeployJarIgnoringErrors
  • createExpectingDMNMessages
  • createJarIgnoringErrors
  • createListener
  • getKieContainerIgnoringErrors
  • typeSafeGetKieRuntime

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
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now