org.kie.dmn.core.util.DynamicTypeUtils java code examples

@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"));
}

@Test
public void testDROOLS2286bis() {
  // DROOLS-2286 (map case)
  final Map<String, Object> johnCena = prototype(entry("name", "John"), entry("surname", "Cena"));
  final Map<String, Object> leslieBrown = prototype(entry("name", "Leslie"), entry("surname", "Brown"));
  final Map<String, Object> johnWick = prototype(entry("name", "John"), entry("surname", "Wick"));
  final List<Map<String, Object>> personList = new ArrayList<>();
  personList.add(johnCena);
  personList.add(leslieBrown);
  personList.add(johnWick);
  final DMNContext context = DMNFactory.newContext();
  context.set("PersonList", personList);
  assertDROOLS2286(context);
}

@SafeVarargs
public static <K, V> Map<K, V> mapOf(Map.Entry<K, V>... attributes) {
  return prototype(attributes);
}

private void testAllowDMNAPItoEvaluateDirectDependencyImportedDecisions_evaluateResultsAndCheck(final DMNRuntime runtime, final Function<DMNContext, DMNResult> fn) {
  final DMNContext context = runtime.newContext();
  context.set("modelA", mapOf(entry("Person name", "John")));
  final DMNResult evaluateAll = fn.apply(context);
  LOG.debug("{}", evaluateAll);
  LOG.debug("{}", evaluateAll.getDecisionResults());
  assertThat(DMNRuntimeUtil.formatMessages(evaluateAll.getMessages()), evaluateAll.hasErrors(), is(false));
  assertThat(evaluateAll.getDecisionResultByName("Evaluating Say Hello").getResult(), is("Evaluating Say Hello to: Hello, John"));
  assertThat(evaluateAll.getDecisionResultByName("modelA.Greet the Person").getResult(), is("Hello, John"));
}

@Test
public void testSingletonlist_function_call() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntime("singletonlist_fuction_call.dmn", this.getClass() );
  final DMNModel dmnModel = runtime.getModel(
      "http://www.trisotech.com/definitions/_0768879b-5ee1-410f-92f0-7732573b069d",
      "expression function subst [a] with a" );
  assertThat( dmnModel, notNullValue() );
  assertThat( DMNRuntimeUtil.formatMessages( dmnModel.getMessages() ), dmnModel.hasErrors(), is( false ) );
  
  final DMNContext ctx = runtime.newContext();
  ctx.set("InputLineItem", prototype(entry("Line", "0015"), entry("Description", "additional Battery")));
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, ctx );
    assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( false ) );
  final DMNContext result = dmnResult.getContext();
  assertThat( result.get("The Battery"), is( prototype(entry("Line", "0010"), entry("Description", "Battery")) ) );
  assertThat( (List<?>)result.get("Remove Battery"), contains( prototype(entry("Line", "0020"), entry("Description", "Case")),
                                 prototype(entry("Line", "0030"), entry("Description", "Power Supply"))
                                 ) );
  assertThat( (List<?>)result.get("Remove Battery"), not( contains( prototype(entry("Line", "0010"), entry("Description", "Battery")) ) ) );
  
  assertThat( (List<?>)result.get("Insert before Line 0020"), contains( prototype(entry("Line", "0010"), entry("Description", "Battery")), 
                                     prototype(entry("Line", "0015"), entry("Description", "additional Battery")), 
                                     prototype(entry("Line", "0020"), entry("Description", "Case")),
                                     prototype(entry("Line", "0030"), entry("Description", "Power Supply"))
                                     ) );
}

private static void testDecisionService20180920_testEvaluateAll(final DMNRuntime runtime, final DMNModel dmnModel) {
  final DMNContext context = DMNFactory.newContext();
  context.set("Model A", mapOf(entry("Input 1", "input 1 value")));
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context);
  LOG.debug("{}", dmnResult);
  dmnResult.getDecisionResults().forEach(x -> LOG.debug("{}", x));
  assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));
  final DMNContext result = dmnResult.getContext();
  assertThat(result.get("Decision B"), is("input 1 value"));
  assertThat(result.get("Invoke Decision B DS"), is("A value"));
}

@Test
public void testRelationwithemptycell() {
  // DROOLS-2439
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntime("relation_with_empty_cell.dmn", this.getClass());
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_99a00903-2943-47df-bab1-a32f276617ea", "Relation with empty cell");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  final DMNContext context = DMNFactory.newContext();
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context);
  System.out.println(dmnResult);
  assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));
  final DMNContext result = dmnResult.getContext();
  assertThat(result.get("Decision A"), is(Arrays.asList(prototype(entry("name", null), entry("age", null)),
                             prototype(entry("name", "John"), entry("age", new BigDecimal(1))),
                             prototype(entry("name", null), entry("age", null)),
                             prototype(entry("name", "Matteo"), entry("age", null)))));
}

  private static void testDecisionService20180920_testEvaluateDS(final DMNRuntime runtime, final DMNModel dmnModel) {
    final DMNContext context = DMNFactory.newContext();
    context.set("Model A", mapOf(entry("Input 1", "input 1 value")));

    final DMNResult dmnResult = runtime.evaluateDecisionService(dmnModel, context, "Decision B DS");
    LOG.debug("{}", dmnResult);
    dmnResult.getDecisionResults().forEach(x -> LOG.debug("{}", x));
    assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));

    final DMNContext result = dmnResult.getContext();
    assertThat(result.getAll(), not(hasEntry(is("Invoke Decision B DS"), anything()))); // we invoked only the Decision Service, not this other Decision in the model.
    assertThat(result.get("Decision B"), is("input 1 value"));
  }
}

@Test
public void testTypeInferenceForNestedContextAnonymousEntry() {
  // DROOLS-1585
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntime("PersonListHelloBKM2.dmn", this.getClass() );
  final DMNModel dmnModel = runtime.getModel(
      "http://www.trisotech.com/definitions/_7e41a76e-2df6-4899-bf81-ae098757a3b6",
      "PersonListHelloBKM2" );
  assertThat( dmnModel, notNullValue() );
  assertThat( DMNRuntimeUtil.formatMessages( dmnModel.getMessages() ), dmnModel.hasErrors(), is( false ) );
  
  final DMNContext context = runtime.newContext();
  
  final Map<String, Object> p1 = prototype(entry("Full Name", "John Doe"), entry("Age", 33) );
  final Map<String, Object> p2 = prototype(entry("Full Name", "47"), entry("Age", 47) );
  
  context.set("My Input Data", Arrays.asList(p1, p2));
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context );
  final DMNContext result = dmnResult.getContext();
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( false ) );
  assertThat( (List<?>)result.get("My Decision"), contains( prototype( entry("Full Name", "Prof. John Doe"), entry("Age", EvalHelper.coerceNumber(33)) ),
                               prototype( entry("Full Name", "Prof. 47"), entry("Age", EvalHelper.coerceNumber(47)) ) 
                               ) );
}

  private void check_testDMN12typeRefInformationItem(String filename) {
    final DMNRuntime runtime = DMNRuntimeUtil.createRuntime(filename, this.getClass());
    final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_fe2fd9ea-5928-4a35-b218-036de5798776", "Drawing 1");
    assertThat(dmnModel, notNullValue());
    assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));

    final DMNContext emptyContext = DMNFactory.newContext();

    final DMNResult dmnResult = runtime.evaluateAll(dmnModel, emptyContext);
    LOG.debug("{}", dmnResult);
    assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));

    final DMNContext result = dmnResult.getContext();
    assertThat(result.get("invoke the a function"), is("Hello World"));
    assertThat(result.get("the list of vowels"), is(Arrays.asList("a", "e", "i", "o", "u")));
    assertThat(result.get("a Person"), is(mapOf(entry("name", "John"),
                          entry("surname", "Doe"),
                          entry("age", BigDecimal.valueOf(47)))));
  }
}

@Test
public void testEnhancedForLoop2() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntime("MACD-enhanced_iteration.dmn", this.getClass());
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/definitions/_6cfe7d88-6741-45d1-968c-b61a597d0964", "MACD-enhanced iteration");
  assertThat(dmnModel, notNullValue());
  assertThat(DMNRuntimeUtil.formatMessages(dmnModel.getMessages()), dmnModel.hasErrors(), is(false));
  final DMNContext context = DMNFactory.newContext();
  final Map<String, Object> d1 = prototype(entry("aDate", LocalDate.of(2018, 3, 5)), entry("Close", 1010));
  final Map<String, Object> d2 = prototype(entry("aDate", LocalDate.of(2018, 3, 6)), entry("Close", 1020));
  final Map<String, Object> d3 = prototype(entry("aDate", LocalDate.of(2018, 3, 7)), entry("Close", 1030));
  context.set("DailyTable", Arrays.asList(d1, d2, d3));
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context);
  assertThat(DMNRuntimeUtil.formatMessages(dmnResult.getMessages()), dmnResult.hasErrors(), is(false));
  final DMNContext resultContext = dmnResult.getContext();
  assertThat(((Map<String, Object>) ((List) resultContext.get("MACDTable")).get(0)).get("aDate"), is(LocalDate.of(2018, 3, 5)));
  assertThat(((Map<String, Object>) ((List) resultContext.get("MACDTable")).get(1)).get("aDate"), is(LocalDate.of(2018, 3, 6)));
  assertThat(((Map<String, Object>) ((List) resultContext.get("MACDTable")).get(2)).get("aDate"), is(LocalDate.of(2018, 3, 7)));
}

@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));
}

context.set("TheBook", Arrays.asList(prototype(entry("Title", "55"), entry("Price", new BigDecimal(5)), entry("Quantity", new BigDecimal(5))),
                   prototype(entry("Title", "510"), entry("Price", new BigDecimal(5)), entry("Quantity", new BigDecimal(10))),
                   prototype(entry("Title", "810"), entry("Price", new BigDecimal(8)), entry("Quantity", new BigDecimal(10))),
                   prototype(entry("Title", "85"), entry("Price", new BigDecimal(8)), entry("Quantity", new BigDecimal(5))),
                   prototype(entry("Title", "66"), entry("Price", new BigDecimal(6)), entry("Quantity", new BigDecimal(6)))));

@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 testForLoopTypeCheck() {
  // DROOLS-1580
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntime("PersonListHelloBKM.dmn", this.getClass() );
  final DMNModel dmnModel = runtime.getModel(
      "http://www.trisotech.com/definitions/_ec5a78c7-a317-4c39-8310-db59be60f1c8",
      "PersonListHelloBKM" );
  assertThat( dmnModel, notNullValue() );
  assertThat( DMNRuntimeUtil.formatMessages( dmnModel.getMessages() ), dmnModel.hasErrors(), is( false ) );
  
  final DMNContext context = runtime.newContext();
  
  final Map<String, Object> p1 = prototype(entry("Full Name", "John Doe"), entry("Age", 33) );
  final Map<String, Object> p2 = prototype(entry("Full Name", "47"), entry("Age", 47) );
  
  context.set("My Input Data", Arrays.asList(p1, p2));
  final DMNResult dmnResult = runtime.evaluateAll(dmnModel, context );
  final DMNContext result = dmnResult.getContext();
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult.getMessages() ), dmnResult.hasErrors(), is( false ) );
  assertThat( (List<?>)result.get("My Decision"), contains( "The person named John Doe is 33 years old.",
                               "The person named 47 is 47 years old.") );
}

@Test
public void testImport() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntimeWithAdditionalResources("Importing_Model.dmn",
                                          this.getClass(),
                                          "Imported_Model.dmn");
  final DMNModel importedModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_f27bb64b-6fc7-4e1f-9848-11ba35e0df36",
                          "Imported Model");
  assertThat(importedModel, notNullValue());
  for (final DMNMessage message : importedModel.getMessages()) {
    LOG.debug("{}", message);
  }
  final DMNModel dmnModel = runtime.getModel("http://www.trisotech.com/dmn/definitions/_f79aa7a4-f9a3-410a-ac95-bea496edab52",
                        "Importing Model");
  assertThat(dmnModel, notNullValue());
  for (final DMNMessage message : dmnModel.getMessages()) {
    LOG.debug("{}", message);
  }
  final DMNContext context = runtime.newContext();
  context.set("A Person", mapOf(entry("name", "John"), entry("age", 47)));
  final DMNResult evaluateAll = runtime.evaluateAll(dmnModel, context);
  for (final DMNMessage message : evaluateAll.getMessages()) {
    LOG.debug("{}", message);
  }
  LOG.debug("{}", evaluateAll);
  assertThat(evaluateAll.getDecisionResultByName("Greeting").getResult(), is("Hello John!"));
}

final Map<String, DMNType> personPrototype = prototype(entry("name", FEEL_STRING), entry("age", FEEL_NUMBER));
final DMNType dmnPerson = typeRegistry.registerType(new CompositeTypeImpl(testNS, "person", null, false, personPrototype, null, null));
final DMNType dmnPersonList = typeRegistry.registerType(new CompositeTypeImpl(testNS, "personList", null, true, null, dmnPerson, null));
final Map<String, Object> instanceBob = prototype(entry("name", "Bob"), entry("age", 42));
final Map<String, Object> instanceJohn = prototype(entry("name", "John"), entry("age", 47));
final Map<String, Object> instanceNOTaPerson = prototype(entry("name", "NOTAPERSON"));

@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 testAllowedValuesChecks() {
  final DMNRuntime runtime = DMNRuntimeUtil.createRuntime( "AllowedValuesChecks.dmn", this.getClass() );
  final DMNModel dmnModel = runtime.getModel(
      "http://www.trisotech.com/definitions/_238bd96d-47cd-4746-831b-504f3e77b442",
      "AllowedValuesChecks" );
  assertThat( dmnModel, notNullValue() );
  assertThat( DMNRuntimeUtil.formatMessages( dmnModel.getMessages() ), dmnModel.hasErrors(), is( false ) );
  final DMNContext ctx1 = runtime.newContext();
  ctx1.set("p1", prototype(entry("Name", "P1"), entry("Interests", Collections.singletonList("Golf"))));
  final DMNResult dmnResult1 = runtime.evaluateAll( dmnModel, ctx1 );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult1.getMessages() ), dmnResult1.hasErrors(), is( false ) );
  assertThat( dmnResult1.getContext().get( "MyDecision" ), is( "The Person P1 likes 1 thing(s)." ) );
  final DMNContext ctx2 = runtime.newContext();
  ctx2.set("p1", prototype(entry("Name", "P2"), entry("Interests", Collections.singletonList("x"))));
  final DMNResult dmnResult2 = runtime.evaluateAll( dmnModel, ctx2 );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult2.getMessages() ), dmnResult2.hasErrors(), is( true ) );
  assertThat( dmnResult2.getMessages().stream().anyMatch( m -> m.getMessageType().equals( DMNMessageType.ERROR_EVAL_NODE ) ), is( true ) );
  final DMNContext ctx3 = runtime.newContext();
  ctx3.set("p1", prototype(entry("Name", "P3"), entry("Interests", Arrays.asList("Golf", "Computer"))));
  final DMNResult dmnResult3 = runtime.evaluateAll( dmnModel, ctx3 );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult3.getMessages() ), dmnResult3.hasErrors(), is( false ) );
  assertThat( dmnResult3.getContext().get( "MyDecision" ), is( "The Person P3 likes 2 thing(s)." ) );
  final DMNContext ctx4 = runtime.newContext();
  ctx4.set("p1", prototype(entry("Name", "P4"), entry("Interests", Arrays.asList("Golf", "x"))));
  final DMNResult dmnResult4 = runtime.evaluateAll( dmnModel, ctx4 );
  assertThat( DMNRuntimeUtil.formatMessages( dmnResult4.getMessages() ), dmnResult4.hasErrors(), is( true ) );
  assertThat( dmnResult4.getMessages().stream().anyMatch( m -> m.getMessageType().equals( DMNMessageType.ERROR_EVAL_NODE ) ), is( true ) );
}

@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"));
}

Most used methods

Popular in Java

Running tasks concurrently on multiple threads
scheduleAtFixedRate (ScheduledExecutorService)
getSupportFragmentManager (FragmentActivity)
scheduleAtFixedRate (Timer)
Table (com.google.common.collect)
A collection that associates an ordered pair of keys, called a row key and a column key, with a sing
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
Kernel (java.awt.image)
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
UUID (java.util)
UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul
BasicDataSource (org.apache.commons.dbcp)
Basic implementation of javax.sql.DataSource that is configured via JavaBeans properties. This is no
Top PhpStorm plugins

How to useDynamicTypeUtils in org.kie.dmn.core.util

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

How to use
DynamicTypeUtils
in
org.kie.dmn.core.util