Integrate MRI projects for Neon

[controller.git] / opendaylight / md-sal / sal-distributed-datastore / src / test / java / org / opendaylight / controller / cluster / databroker / ConcurrentDOMDataBrokerTest.java

diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java
index ca255c82501da2a9ed4f1dfd4fc0802f253ea68e..7f0e0f5577621ca26cff4ab371c964108f727c60 100644 (file)
--- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java
+++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ConcurrentDOMDataBrokerTest.java
@@ -19,10 +19,14 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFalseFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateNullFluentFuture;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateTrueFluentFuture;
 
 import com.google.common.base.Throwables;
+import com.google.common.collect.ClassToInstanceMap;
 import com.google.common.collect.ImmutableMap;
-import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FluentFuture;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -33,7 +37,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.SynchronousQueue;
@@ -48,9 +51,9 @@ import org.mockito.InOrder;
 import org.mockito.stubbing.Answer;
 import org.opendaylight.controller.cluster.datastore.DistributedDataStore;
 import org.opendaylight.controller.cluster.datastore.exceptions.NoShardLeaderException;
+import org.opendaylight.mdsal.common.api.CommitInfo;
 import org.opendaylight.mdsal.common.api.DataStoreUnavailableException;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.common.api.TransactionChainListener;
 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
 import org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService;
@@ -61,6 +64,8 @@ import org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeReadWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
 import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
+import org.opendaylight.mdsal.dom.broker.TransactionCommitFailedExceptionMapper;
 import org.opendaylight.mdsal.dom.spi.store.DOMStore;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction;
 import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction;
@@ -118,30 +123,31 @@ public class ConcurrentDOMDataBrokerTest {
                 new Thread(() -> {
                     Uninterruptibles.awaitUninterruptibly(asyncCanCommitContinue,
                             10, TimeUnit.SECONDS);
-                    future.set(true);
+                    future.set(Boolean.TRUE);
                 }).start();
             } else {
-                future.set(true);
+                future.set(Boolean.TRUE);
             }
 
             return future;
         };
 
         doAnswer(asyncCanCommit).when(mockCohort1).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).preCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).commit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).preCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).commit();
 
-        doReturn(Futures.immediateFuture(true)).when(mockCohort2).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).preCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).commit();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort2).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).preCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).commit();
 
-        ListenableFuture<Void> future = coordinator.submit(transaction, Arrays.asList(mockCohort1, mockCohort2));
+        ListenableFuture<? extends CommitInfo> future =
+                coordinator.commit(transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         final CountDownLatch doneLatch = new CountDownLatch(1);
         final AtomicReference<Throwable> caughtEx = new AtomicReference<>();
-        Futures.addCallback(future, new FutureCallback<Void>() {
+        Futures.addCallback(future, new FutureCallback<CommitInfo>() {
             @Override
-            public void onSuccess(final Void result) {
+            public void onSuccess(final CommitInfo result) {
                 doneLatch.countDown();
             }
 
@@ -154,7 +160,7 @@ public class ConcurrentDOMDataBrokerTest {
 
         asyncCanCommitContinue.countDown();
 
-        assertEquals("Submit complete", true, doneLatch.await(5, TimeUnit.SECONDS));
+        assertTrue("Submit complete", doneLatch.await(5, TimeUnit.SECONDS));
 
         if (caughtEx.get() != null) {
             Throwables.throwIfUnchecked(caughtEx.get());
@@ -174,31 +180,31 @@ public class ConcurrentDOMDataBrokerTest {
 
     @Test
     public void testSubmitWithNegativeCanCommitResponse() throws Exception {
-        doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
 
-        doReturn(Futures.immediateFuture(false)).when(mockCohort2).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+        doReturn(Futures.immediateFuture(Boolean.FALSE)).when(mockCohort2).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
 
         DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
-        doReturn(Futures.immediateFuture(false)).when(mockCohort3).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
+        doReturn(Futures.immediateFuture(Boolean.FALSE)).when(mockCohort3).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort3).abort();
 
-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        ListenableFuture<? extends CommitInfo> future = coordinator.commit(
                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, null, mockCohort1, mockCohort2, mockCohort3);
     }
 
-    private static void assertFailure(final CheckedFuture<Void, TransactionCommitFailedException> future,
-            final Exception expCause, final DOMStoreThreePhaseCommitCohort... mockCohorts)
-                    throws Exception {
+    private static void assertFailure(final ListenableFuture<?> future, final Exception expCause,
+            final DOMStoreThreePhaseCommitCohort... mockCohorts) throws Exception {
         try {
-            future.checkedGet(5, TimeUnit.SECONDS);
+            future.get(5, TimeUnit.SECONDS);
             fail("Expected TransactionCommitFailedException");
-        } catch (TransactionCommitFailedException e) {
+        } catch (ExecutionException e) {
+            TransactionCommitFailedException tcf = TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER.apply(e);
             if (expCause != null) {
-                assertSame("Expected cause", expCause.getClass(), e.getCause().getClass());
+                assertSame("Expected cause", expCause.getClass(), tcf.getCause().getClass());
             }
 
             InOrder inOrder = inOrder((Object[])mockCohorts);
@@ -212,14 +218,14 @@ public class ConcurrentDOMDataBrokerTest {
 
     @Test
     public void testSubmitWithCanCommitException() throws Exception {
-        doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
 
         IllegalStateException cause = new IllegalStateException("mock");
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
 
-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(
                 transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);
@@ -227,14 +233,14 @@ public class ConcurrentDOMDataBrokerTest {
 
     @Test
     public void testSubmitWithCanCommitDataStoreUnavailableException() throws Exception {
-        doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
         NoShardLeaderException rootCause = new NoShardLeaderException("mock");
         DataStoreUnavailableException cause = new DataStoreUnavailableException(rootCause.getMessage(), rootCause);
         doReturn(Futures.immediateFailedFuture(rootCause)).when(mockCohort2).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
 
-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(
             transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);
@@ -242,22 +248,22 @@ public class ConcurrentDOMDataBrokerTest {
 
     @Test
     public void testSubmitWithPreCommitException() throws Exception {
-        doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).preCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).preCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
 
-        doReturn(Futures.immediateFuture(true)).when(mockCohort2).canCommit();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort2).canCommit();
         IllegalStateException cause = new IllegalStateException("mock");
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).preCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
 
         DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
-        doReturn(Futures.immediateFuture(true)).when(mockCohort3).canCommit();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort3).canCommit();
         doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock2")))
                 .when(mockCohort3).preCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort3).abort();
 
-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(
                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, cause, mockCohort1, mockCohort2, mockCohort3);
@@ -265,25 +271,25 @@ public class ConcurrentDOMDataBrokerTest {
 
     @Test
     public void testSubmitWithCommitException() throws Exception {
-        doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).preCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).commit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort1).abort();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).preCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).commit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort1).abort();
 
-        doReturn(Futures.immediateFuture(true)).when(mockCohort2).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).preCommit();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort2).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).preCommit();
         IllegalStateException cause = new IllegalStateException("mock");
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).commit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
 
         DOMStoreThreePhaseCommitCohort mockCohort3 = mock(DOMStoreThreePhaseCommitCohort.class);
-        doReturn(Futures.immediateFuture(true)).when(mockCohort3).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort3).preCommit();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort3).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort3).preCommit();
         doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock2")))
                 .when(mockCohort3).commit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort3).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort3).abort();
 
-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(
                 transaction, Arrays.asList(mockCohort1, mockCohort2, mockCohort3));
 
         assertFailure(future, cause, mockCohort1, mockCohort2, mockCohort3);
@@ -291,15 +297,15 @@ public class ConcurrentDOMDataBrokerTest {
 
     @Test
     public void testSubmitWithAbortException() throws Exception {
-        doReturn(Futures.immediateFuture(true)).when(mockCohort1).canCommit();
+        doReturn(immediateTrueFluentFuture()).when(mockCohort1).canCommit();
         doReturn(Futures.immediateFailedFuture(new IllegalStateException("mock abort error")))
                 .when(mockCohort1).abort();
 
         IllegalStateException cause = new IllegalStateException("mock canCommit error");
         doReturn(Futures.immediateFailedFuture(cause)).when(mockCohort2).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort2).abort();
+        doReturn(immediateNullFluentFuture()).when(mockCohort2).abort();
 
-        CheckedFuture<Void, TransactionCommitFailedException> future = coordinator.submit(
+        FluentFuture<? extends CommitInfo> future = coordinator.commit(
                 transaction, Arrays.asList(mockCohort1, mockCohort2));
 
         assertFailure(future, cause, mockCohort1, mockCohort2);
@@ -433,8 +439,8 @@ public class ConcurrentDOMDataBrokerTest {
 
         doReturn(mockStoreReadWriteTransaction).when(operationalDomStore).newReadWriteTransaction();
         doReturn(mockCohort).when(mockStoreReadWriteTransaction).ready();
-        doReturn(Futures.immediateFuture(false)).when(mockCohort).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohort).abort();
+        doReturn(immediateFalseFluentFuture()).when(mockCohort).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohort).abort();
 
         final CountDownLatch latch = new CountDownLatch(1);
         final List<DOMStoreThreePhaseCommitCohort> commitCohorts = new ArrayList<>();
@@ -443,18 +449,18 @@ public class ConcurrentDOMDataBrokerTest {
                 LogicalDatastoreType.OPERATIONAL, operationalDomStore, LogicalDatastoreType.CONFIGURATION,
                 configDomStore), futureExecutor) {
             @Override
-            public CheckedFuture<Void, TransactionCommitFailedException> submit(DOMDataTreeWriteTransaction writeTx,
+            public FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction writeTx,
                     Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
                 commitCohorts.addAll(cohorts);
                 latch.countDown();
-                return super.submit(writeTx, cohorts);
+                return super.commit(writeTx, cohorts);
             }
         }) {
             DOMDataTreeReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();
 
             domDataReadWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.EMPTY);
 
-            domDataReadWriteTransaction.submit();
+            domDataReadWriteTransaction.commit();
 
             assertTrue(latch.await(10, TimeUnit.SECONDS));
 
@@ -475,12 +481,12 @@ public class ConcurrentDOMDataBrokerTest {
         doReturn(configTransaction).when(configDomStore).newReadWriteTransaction();
 
         doReturn(mockCohortOperational).when(operationalTransaction).ready();
-        doReturn(Futures.immediateFuture(false)).when(mockCohortOperational).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohortOperational).abort();
+        doReturn(immediateFalseFluentFuture()).when(mockCohortOperational).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohortOperational).abort();
 
         doReturn(mockCohortConfig).when(configTransaction).ready();
-        doReturn(Futures.immediateFuture(false)).when(mockCohortConfig).canCommit();
-        doReturn(Futures.immediateFuture(null)).when(mockCohortConfig).abort();
+        doReturn(immediateFalseFluentFuture()).when(mockCohortConfig).canCommit();
+        doReturn(immediateNullFluentFuture()).when(mockCohortConfig).abort();
 
         final CountDownLatch latch = new CountDownLatch(1);
         final List<DOMStoreThreePhaseCommitCohort> commitCohorts = new ArrayList<>();
@@ -490,11 +496,11 @@ public class ConcurrentDOMDataBrokerTest {
                 configDomStore), futureExecutor) {
             @Override
             @SuppressWarnings("checkstyle:hiddenField")
-            public CheckedFuture<Void, TransactionCommitFailedException> submit(DOMDataTreeWriteTransaction writeTx,
+            public FluentFuture<? extends CommitInfo> commit(DOMDataTreeWriteTransaction writeTx,
                     Collection<DOMStoreThreePhaseCommitCohort> cohorts) {
                 commitCohorts.addAll(cohorts);
                 latch.countDown();
-                return super.submit(writeTx, cohorts);
+                return super.commit(writeTx, cohorts);
             }
         }) {
             DOMDataTreeReadWriteTransaction domDataReadWriteTransaction = dataBroker.newReadWriteTransaction();
@@ -504,7 +510,7 @@ public class ConcurrentDOMDataBrokerTest {
             domDataReadWriteTransaction.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.EMPTY,
                     mock(NormalizedNode.class));
 
-            domDataReadWriteTransaction.submit();
+            domDataReadWriteTransaction.commit();
 
             assertTrue(latch.await(10, TimeUnit.SECONDS));
 
@@ -519,7 +525,7 @@ public class ConcurrentDOMDataBrokerTest {
                 LogicalDatastoreType.OPERATIONAL, domStore, LogicalDatastoreType.CONFIGURATION, domStore),
                 futureExecutor)) {
 
-            dataBroker.createTransactionChain(mock(TransactionChainListener.class));
+            dataBroker.createTransactionChain(mock(DOMTransactionChainListener.class));
 
             verify(domStore, times(2)).createTransactionChain();
         }
@@ -540,7 +546,7 @@ public class ConcurrentDOMDataBrokerTest {
             doReturn(operationalTransaction).when(mockChain).newWriteOnlyTransaction();
 
             DOMTransactionChain transactionChain = dataBroker.createTransactionChain(
-                    mock(TransactionChainListener.class));
+                    mock(DOMTransactionChainListener.class));
 
             DOMDataTreeWriteTransaction domDataWriteTransaction = transactionChain.newWriteOnlyTransaction();
 
@@ -558,15 +564,13 @@ public class ConcurrentDOMDataBrokerTest {
                 LogicalDatastoreType.OPERATIONAL, domStore, LogicalDatastoreType.CONFIGURATION, domStore),
                 futureExecutor)) {
 
-            CheckedFuture<Void, TransactionCommitFailedException> submit1 =
-                    dataBroker.newWriteOnlyTransaction().submit();
+            FluentFuture<? extends CommitInfo> submit1 = dataBroker.newWriteOnlyTransaction().commit();
 
             assertNotNull(submit1);
 
             submit1.get();
 
-            CheckedFuture<Void, TransactionCommitFailedException> submit2 =
-                    dataBroker.newReadWriteTransaction().submit();
+            FluentFuture<? extends CommitInfo> submit2 = dataBroker.newReadWriteTransaction().commit();
 
             assertNotNull(submit2);
 
@@ -582,12 +586,11 @@ public class ConcurrentDOMDataBrokerTest {
                 LogicalDatastoreType.OPERATIONAL, mockOperStore,
                 LogicalDatastoreType.CONFIGURATION, mockConfigStore), futureExecutor)) {
 
-            Map<Class<? extends DOMDataBrokerExtension>, DOMDataBrokerExtension> supportedExtensions =
-                    dataBroker.getSupportedExtensions();
-            assertNotNull(supportedExtensions.get(DOMDataTreeChangeService.class));
+            ClassToInstanceMap<DOMDataBrokerExtension> supportedExtensions = dataBroker.getExtensions();
+            assertNotNull(supportedExtensions.getInstance(DOMDataTreeChangeService.class));
 
-            DOMDataTreeCommitCohortRegistry cohortRegistry =
-                    (DOMDataTreeCommitCohortRegistry) supportedExtensions.get(DOMDataTreeCommitCohortRegistry.class);
+            DOMDataTreeCommitCohortRegistry cohortRegistry = supportedExtensions.getInstance(
+                DOMDataTreeCommitCohortRegistry.class);
             assertNotNull(cohortRegistry);
 
             DOMDataTreeCommitCohort mockCohort = mock(DOMDataTreeCommitCohort.class);