<scope>test</scope>
</dependency>
</dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
<scm>
<connection>scm:git:http://git.opendaylight.org/gerrit/controller.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
/**
- *
* Marker interface for MD-SAL services which are available for users of MD-SAL.
*
+ * <p>
* BindingService is marker interface for infrastructure services provided by
* the SAL. These services may be session-specific, and wrapped by custom
* delegator patterns in order to introduce additional semantics / checks
/**
* A chain of transactions.
+ *
* <p>
* For more information about transaction chaining and transaction chains
* see {@link TransactionChain}.
* @see TransactionChain
*
*/
-public interface BindingTransactionChain extends TransactionFactory, TransactionChain<InstanceIdentifier<?>, DataObject> {
- /**
- * {@inheritDoc}
- */
+public interface BindingTransactionChain extends TransactionFactory,
+ TransactionChain<InstanceIdentifier<?>, DataObject> {
+
@Override
ReadTransaction newReadOnlyTransaction();
- /**
- * {@inheritDoc}
- */
@Override
WriteTransaction newWriteOnlyTransaction();
}
* Create a {@link DataTreeWriteCursor} anchored at the specified path.
* There can only be one cursor open at a time.
*
+ * <p>
* @param path Path at which the cursor is to be anchored
* @return write cursor at the desired location.
* @throws IllegalStateException when there's an open cursor, or this transaction is closed already.
/**
* Cancels the transaction.
*
+ * <p>
* Transactions can only be cancelled if it was not yet submited.
*
+ * <p>
* Invoking cancel() on failed or already canceled will have no effect, and transaction is
* considered cancelled.
*
+ * <p>
* Invoking cancel() on finished transaction (future returned by {@link #submit()} already
* successfully completed) will always fail (return false).
*
/**
* Submits this transaction to be asynchronously applied to update the logical data tree. The
* returned CheckedFuture conveys the result of applying the data changes.
+ *
* <p>
* <b>Note:</b> It is strongly recommended to process the CheckedFuture result in an
* asynchronous manner rather than using the blocking get() method.
*
+ * <p>
* This call logically seals the transaction, which prevents the client from further changing
* data tree using this transaction's cursor. Any subsequent calls to
* <code>createCursorCursor(DOMDataTreeIdentifier</code>
* or any of the cursor's methods will fail with {@link IllegalStateException}.
*
+ * <p>
* The transaction is marked as submitted and enqueued into the shard back-end for
* processing.
*/
package org.opendaylight.mdsal.binding.api;
import org.opendaylight.mdsal.common.api.AsyncDataBroker;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.TransactionChainFactory;
import org.opendaylight.mdsal.common.api.TransactionChainListener;
-
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
/**
* Provides access to a conceptual data tree store and also provides the ability to
* subscribe for changes to data under a given branch of the tree.
+ *
* <p>
* For more information on usage, please see the documentation in {@link AsyncDataBroker}.
*
* @see TransactionChainFactory
*/
public interface DataBroker extends AsyncDataBroker<InstanceIdentifier<?>, DataObject>,
- TransactionChainFactory<InstanceIdentifier<?>, DataObject>, TransactionFactory, BindingService, DataTreeChangeService {
- /**
- * {@inheritDoc}
- */
+ TransactionChainFactory<InstanceIdentifier<?>, DataObject>, TransactionFactory, BindingService,
+ DataTreeChangeService {
+
@Override
ReadTransaction newReadOnlyTransaction();
- /**
- * {@inheritDoc}
- */
@Override
WriteTransaction newWriteOnlyTransaction();
- /**
- * {@inheritDoc}
- */
@Override
BindingTransactionChain createTransactionChain(TransactionChainListener listener);
}
/**
* Modified Data Object.
*
+ *<p>
* Represents modification of Data Object
- * .
+ *
+ *<p>
* @param <T> Type of modified object
*
*/
-public interface DataObjectModification<T extends DataObject> extends org.opendaylight.yangtools.concepts.Identifiable<PathArgument> {
+public interface DataObjectModification<T extends DataObject> extends
+ org.opendaylight.yangtools.concepts.Identifiable<PathArgument> {
/**
* Represents type of modification which has occured.
*/
enum ModificationType {
/**
- *
* Child node (direct or indirect) was modified.
*
*/
SUBTREE_MODIFIED,
/**
- *
* Node was explicitly created / overwritten.
*
*/
WRITE,
/**
- *
* Node was deleted.
*
*/
@Nonnull Class<T> getDataType();
/**
- *
- * Returns type of modification
+ * Returns type of modification.
*
* @return type Type of performed modification.
*/
* Returns before-state of top level container. Implementations are encouraged, but not required
* to provide this state.
*
- *
* @return State of object before modification. Null if subtree was not present, or the
* implementation cannot provide the state.
*/
* @throws IllegalArgumentException If supplied {@code childType} class is not valid child according
* to generated model.
*/
- <C extends ChildOf<? super T>> Collection<DataObjectModification<C>> getModifiedChildren(@Nonnull Class<C> childType);
+ <C extends ChildOf<? super T>> Collection<DataObjectModification<C>> getModifiedChildren(
+ @Nonnull Class<C> childType);
/**
* Returns container child modification if {@code child} was modified by this
* modification.
*
+ *<p>
* For accessing all modified list items consider iterating over {@link #getModifiedChildren()}.
*
* @param child Type of child - must be only container
* @throws IllegalArgumentException If supplied {@code child} class is not valid child according
* to generated model.
*/
- @Nullable <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(@Nonnull Class<C> child);
+ @Nullable <C extends ChildOf<? super T>> DataObjectModification<C> getModifiedChildContainer(
+ @Nonnull Class<C> child);
/**
* Returns augmentation child modification if {@code augmentation} was modified by this
* modification.
*
+ *<p>
* For accessing all modified list items consider iterating over {@link #getModifiedChildren()}.
*
* @param augmentation Type of augmentation - must be only container
* @throws IllegalArgumentException If supplied {@code augmentation} class is not valid augmentation
* according to generated model.
*/
- @Nullable <C extends Augmentation<T> & DataObject> DataObjectModification<C> getModifiedAugmentation(@Nonnull Class<C> augmentation);
+ @Nullable <C extends Augmentation<T> & DataObject> DataObjectModification<C> getModifiedAugmentation(
+ @Nonnull Class<C> augmentation);
/**
* @throws IllegalArgumentException If supplied {@code listItem} class is not valid child according
* to generated model.
*/
- <C extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<C>> DataObjectModification<C> getModifiedChildListItem(
- @Nonnull Class<C> listItem,@Nonnull K listKey);
+ <C extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<C>> DataObjectModification<C>
+ getModifiedChildListItem(@Nonnull Class<C> listItem,@Nonnull K listKey);
/**
* Returns a child modification if a node identified by {@code childArgument} was modified by
* to recover from such events. Event producers are expected to exert reasonable
* effort to suppress such events.
*
+ *<p>
* In other words, it is completely acceptable to observe
* a {@link DataObjectModification}, while the state observed before and
* after- data items compare as equal.
* Registers a {@link DataTreeChangeListener} to receive
* notifications when data changes under a given path in the conceptual data
* tree.
+ *
* <p>
* You are able to register for notifications for any node or subtree
* which can be represented using {@link DataTreeIdentifier}.
- * <p>
*
+ * <p>
* You are able to register for data change notifications for a subtree or leaf
* even if it does not exist. You will receive notification once that node is
* created.
+ *
* <p>
* If there is any pre-existing data in the data tree for the path for which you are
* registering, you will receive an initial data change event, which will
* This method returns a {@link ListenerRegistration} object. To
* "unregister" your listener for changes call the {@link ListenerRegistration#close()}
* method on the returned object.
+ *
* <p>
* You MUST explicitly unregister your listener when you no longer want to receive
* notifications. This is especially true in OSGi environments, where failure to
* your listener using {@link ListenerRegistration#close()} to stop
* delivery of change events.
*/
- @Nonnull <T extends DataObject,L extends DataTreeChangeListener<T>> ListenerRegistration<L> registerDataTreeChangeListener(@Nonnull DataTreeIdentifier<T> treeId, @Nonnull L listener);
+ @Nonnull <T extends DataObject,L extends DataTreeChangeListener<T>> ListenerRegistration<L>
+ registerDataTreeChangeListener(@Nonnull DataTreeIdentifier<T> treeId, @Nonnull L listener);
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- * **
- *
* Commit cohort participating in commit of data modification, which can validate data tree
* modifications, with option to reject supplied modification, and with callbacks describing state
* of commit.
* {@link DataTreeCommitCohort}s are hooked up into commit of data tree changes and MAY
* negatively affect performance of data broker / store.
*
+ * <p>
* Implementations of this interface are discouraged, unless you really need ability to veto data
* tree changes, or to provide external state change in sync with visibility of commited data.
*
- *
* <h2>Implementation requirements</h2>
*
* <h3>Correctness assumptions</h3> Implementation SHOULD use only provided
* {@link DataTreeModification} for validation purposes.
*
+ * <p>
* Use of any other external mutable state is discouraged, implementation MUST NOT use any
* transaction related APIs on same data broker / data store instance during invocation of
* callbacks, except ones provided as argument. Note that this MAY BE enforced by some
* implementations of {@link DataBroker} or Commit coordinator
*
+ * <p>
* Note that this may be enforced by some implementations of {@link DataTreeCommitCohortRegistry}
* and such calls may fail.
*
* {@link PostCanCommitStep#preCommit()} and
* {@link org.opendaylight.mdsal.common.api.PostPreCommitStep#commit()} callback was invoked.
*
- *
* <h2>Usage patterns</h2>
*
* <h3>Data Tree Validator</h3>
*
+ * <p>
* Validator is implementation, which only validates {@link DataTreeModification} and does not
* retain any state derived from edited data - does not care if {@link DataTreeModification} was
* rejected afterwards or transaction was cancelled.
*
+ * <p>
* Implementation may opt-out from receiving {@code preCommit()}, {@code commit()}, {@code abort()}
* callbacks by returning {@link PostCanCommitStep#NOOP}.
*
+ * <p>
* TODO: Provide example and describe more usage patterns
*
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- *
* Commit Cohort registry.
*
+ * <p>
* See {@link DataTreeCommitCohort} for more details.
*
* A unique identifier for a particular subtree. It is composed of the logical
* data store type and the instance identifier of the root node.
*/
-public final class DataTreeIdentifier<T extends DataObject> implements Immutable, Path<DataTreeIdentifier<?>>, Serializable {
+public final class DataTreeIdentifier<T extends DataObject> implements Immutable,
+ Path<DataTreeIdentifier<?>>, Serializable {
private static final long serialVersionUID = 1L;
private final InstanceIdentifier<T> rootIdentifier;
private final LogicalDatastoreType datastoreType;
* either submitted or cancelled before another one can be open. Once a transaction is submitted, it
* will proceed to be committed asynchronously.
*
+ *<p>
* Each instance has an upper bound on the number of transactions which can be in-flight, once that
* capacity is exceeded, an attempt to create a new transaction will block until some transactions
* complete.
*
+ *<p>
* Each {@link DataTreeProducer} can be in two logical states, bound and unbound, which define the
* lifecycle rules for when is it legal to create and submit transactions in relationship with
* {@link DataTreeListener} callbacks.
*
+ *<p>
* When a producer is first created, it is unbound. In this state the producer can be accessed by
* any application thread to allocate or submit transactions, as long as the 'single open
* transaction' rule is maintained. The producer and any transaction object MUST NOT be accessed,
* directly or indirectly, from a {@link DataTreeListener} callback.
*
+ * <p>
* When a producer is referenced in a call to
* {@link DataTreeService#registerListener(DataTreeListener, java.util.Collection, boolean, java.util.Collection)}
* , an attempt will be made to bind the producer to the specified {@link DataTreeListener}. Such an
CursorAwareWriteTransaction createTransaction(boolean isolated);
/**
- * {@inheritDoc}
+ * {@inheritDoc}.
*
+ *<p>
* When invoked on a {@link DataTreeProducer}, this method has additional restrictions. There
* may not be an open transaction from this producer. The method needs to be invoked in
* appropriate context, e.g. bound or unbound.
*
+ *<p>
* Specified subtrees must be accessible by this producer. Accessible means they are a subset of
* the subtrees specified when the producer is instantiated. The set is further reduced as child
* producers are instantiated -- if you create a producer for /a and then a child for /a/b, /a/b
* is not accessible from the first producer.
*
+ *<p>
* Once this method returns successfully, this (parent) producer loses the ability to access the
* specified paths until the resulting (child) producer is shut down.
*
DataTreeProducer createProducer(@Nonnull Collection<DataTreeIdentifier<?>> subtrees);
/**
- * {@inheritDoc}
+ * {@inheritDoc}.
*
* @throws DataTreeProducerBusyException when there is an open transaction.
*/
* tree are split into data producers and consumers (listeners). Each of them operate on a set of
* subtrees, which need to be declared at instantiation time.
*
+ *<p>
* Returned instances are not thread-safe and expected to be used by a single thread at a time.
* Furthermore, producers may not be accessed from consumer callbacks unless they were specified
* when the listener is registered.
*
+ *<p>
* The service maintains a loop-free topology of producers and consumers. What this means is that a
* consumer is not allowed to access a producer, which affects any of the subtrees it is subscribed
* to. This restriction is in place to ensure the system does not go into a feedback loop, where it
* a smaller number of them will be reported, possibly hiding some data transitions (like
* flaps).
*
+ *<p>
* If the listener wants to write into any producer, that producer has to be mentioned in the
* call to this method. Those producers will be bound exclusively to the registration, so that
* accessing them outside of this listener's callback will trigger an error. Any producers
* mentioned must be idle, e.g. they may not have an open transaction at the time this method is
* invoked.
*
+ *<p>
* Each listener instance can be registered at most once. Implementations of this interface have
* to guarantee that the listener's methods will not be invoked concurrently from multiple
* threads.
import org.opendaylight.yangtools.yang.data.api.schema.tree.BackendFailedException;
/**
- * {@inheritDoc}
+ * {@inheritDoc}.
*
+ * <p>
* In addition this cursor also provides write operations(delete, merge, write).
*/
public interface DataTreeWriteCursor extends DataTreeCursor {
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public interface MountPoint extends Identifiable<InstanceIdentifier<?>>{
+public interface MountPoint extends Identifiable<InstanceIdentifier<?>> {
<T extends BindingService> Optional<T> getService(Class<T> service);
* - {@link #offerNotification(Notification, int, TimeUnit)}, which may block
* for specified time if resources are thin.
*
+ *<p>
* The actual delivery to listeners is asynchronous and implementation-specific.
* Users of this interface should not make any assumptions as to whether the
* notification has or has not been seen.
* Well-known value indicating that the binding-aware implementation is currently not
* able to accept a notification.
*/
- ListenableFuture<Object> REJECTED = Futures.immediateFailedFuture(new NotificationRejectedException("Rejected due to resource constraints."));
+ ListenableFuture<Object> REJECTED = Futures.immediateFailedFuture(
+ new NotificationRejectedException("Rejected due to resource constraints."));
/**
* Publishes a notification to subscribed listeners. This initiates
* notification, but delivery to the listeners can happen asynchronously, potentially after a
* call to this method returns.
*
+ * <p>
* Still guaranteed not to block. Returns Listenable Future which will complete once.
*
* @param notification the notification to publish.
package org.opendaylight.mdsal.binding.api;
/**
- * <p>
* This exception indicates that given notification can not be processed by corresponding mechanism.
* More info can be provided in message.
- * </p>
+ *
* <p>
* Expected use: {@link NotificationPublishService}
- * </p>
*/
public class NotificationRejectedException extends Exception {
private static final long serialVersionUID = 1L;
/**
* Notification broker which allows clients to subscribe for and publish YANG-modeled notifications.
*
+ *<p>
* Each YANG module which defines notifications results in a generated interface
* <code>{ModuleName}Listener</code> which handles all the notifications defined in the YANG model.
* Each notification type translates to a specific method of the form
* method.
*
* <b>Dispatch Listener Example</b>
+ *
* <p>
* Lets assume we have following YANG model:
*
* <pre>
* module example {
* ...
- *
+ *
* notification start {
* ...
* }
- *
+ *
* notification stop {
* ...
* }
* }
* </pre>
*
+ * <p>
* The generated interface will be:
- *
+ *
* <pre>
* public interface ExampleListener extends NotificationListener {
* void onStart(Start notification);
- *
+ *
* void onStop(Stop notification);
* }
* </pre>
- *
+ *
+ * <p>
* The following defines an implementation of the generated interface:
- *
+ *
* <pre>
* public class MyExampleListener implements ExampleListener {
* public void onStart(Start notification) {
* // do something
* }
- *
+ *
* public void onStop(Stop notification) {
* // do something
* }
* }
* </pre>
- *
+ *
+ * <p>
* The implementation is registered as follows:
- *
+ *
* <pre>
* MyExampleListener listener = new MyExampleListener();
* ListenerRegistration<NotificationListener> reg = service.registerNotificationListener(listener);
* </pre>
- *
+ *
+ * <p>
* The <code>onStart</code> method will be invoked when someone publishes a <code>Start</code>
* notification and the <code>onStop</code> method will be invoked when someone publishes a
* <code>Stop</code> notification.
* {@link NotificationListener}. The listener is registered for all notifications present in
* the implemented interface.
*
+ * <p>
* @param listener the listener implementation that will receive notifications.
* @return a {@link ListenerRegistration} instance that should be used to unregister the listener
* by invoking the {@link ListenerRegistration#close()} method when no longer needed.
*/
package org.opendaylight.mdsal.binding.api;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import org.opendaylight.mdsal.common.api.AsyncReadTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.common.api.ReadFailedException;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
/**
* A transaction that provides a stateful read-only view of the data tree.
+ *
* <p>
* For more information on usage and examples, please see the documentation in
* {@link org.opendaylight.mdsal.common.api.AsyncReadTransaction}.
/**
* Reads data from the provided logical data store located at the provided path.
+ *
*<p>
* If the target is a subtree, then the whole subtree is read (and will be
* accessible from the returned data object).
/**
* Provides access to registered Remote Procedure Call (RPC) service implementations. The RPCs are
* defined in YANG models.
+ *
* <p>
* RPC implementations are registered using the {@link RpcProviderService}.
*
* <p>
* The returned instance is not an actual implementation of the RPC service interface, but a
* proxy implementation of the interface that forwards to an actual implementation, if any.
- * <p>
*
+ * <p>
* The following describes the behavior of the proxy when invoking RPC methods:
* <ul>
* <li>If an actual implementation is registered with the MD-SAL, all invocations are forwarded
* </ul>
*
* The returned proxy is automatically updated with the most recent registered implementation.
+ *
* <p>
* The generated RPC method APIs require implementors to return a
* {@link java.util.concurrent.Future Future} instance that wraps the
* {@link java.util.concurrent.Future Future} result. Instead, it is recommended to use
* {@link com.google.common.util.concurrent.JdkFutureAdapters#listenInPoolThread(java.util.concurrent.Future)}
* or
- * {@link com.google.common.util.concurrent.JdkFutureAdapters#listenInPoolThread(java.util.concurrent.Future, java.util.concurrent.Executor)}
- * to listen for Rpc Result. This will asynchronously listen for future result in executor and
- * will not block current thread.
+ * {@link com.google.common.util.concurrent.JdkFutureAdapters#listenInPoolThread(java.util.concurrent.Future,
+ * java.util.concurrent.Executor)} to listen for Rpc Result. This will asynchronously listen for future result
+ * in executor and will not block current thread.
*
* <pre>
* final Future<RpcResult<SomeRpcOutput>> future = someRpcService.someRpc( ... );
- * Futures.addCallback(JdkFutureAdapters.listenInThreadPool(future), new FutureCallback<RpcResult<SomeRpcOutput>>() {
+ * Futures.addCallback(JdkFutureAdapters.listenInThreadPool(future), new FutureCallback<RpcResult<
+ * SomeRpcOutput>>() {
*
* public void onSuccess(RpcResult<SomeRpcOutput> result) {
* // process result ...
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public interface TransactionFactory extends AsyncDataTransactionFactory<InstanceIdentifier<?>, DataObject>{
+public interface TransactionFactory extends AsyncDataTransactionFactory<InstanceIdentifier<?>, DataObject> {
@Override
ReadTransaction newReadOnlyTransaction();
/**
* A transaction that provides mutation capabilities on a data tree.
+ *
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
*/
/**
* Stores a piece of data at the specified path. This acts as an add / replace
* operation, which is to say that whole subtree will be replaced by the specified data.
- * * <p>
+ *
+ * <p>
* This method does not automatically create missing parent nodes. It is equivalent to invoking
* {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
* with <code>createMissingParents</code> set to false.
+ *
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
* <p>
* Stores a piece of data at the specified path. This acts as an add /
* replace operation, which is to say that whole subtree will be replaced by
* the specified data.
+ *
* <p>
* For more information on usage and examples, please see the documentation
* in {@link AsyncWriteTransaction}.
+ *
* <p>
* If you need to make sure that a parent object exists but you do not want
* modify its pre-existing state by using put, consider using {@link #merge}
* instead.
*
+ * <p>
* Note: Using <code>createMissingParents</code> with value true, may
* introduce garbage in data store, or recreate nodes, which were deleted by
* previous transaction.
* Merges a piece of data with the existing data at a specified path. Any pre-existing data
* which is not explicitly overwritten will be preserved. This means that if you store a container,
* its child lists will be merged.
+ *
* <p>
* This method does not automatically create missing parent nodes. It is equivalent to invoking
* {@link #merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
* with <code>createMissingParents</code> set to false.
+ *
* <p>
- * For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
+ * For more information on usage and examples, please see the documentation in
+ * {@link AsyncWriteTransaction}.
+ *
*<p>
* If you require an explicit replace operation, use {@link #put} instead.
* @param store
* Merges a piece of data with the existing data at a specified path. Any
* pre-existing data which is not explicitly overwritten will be preserved.
* This means that if you store a container, its child lists will be merged.
+ *
* <p>
* For more information on usage and examples, please see the documentation
* in {@link AsyncWriteTransaction}.
+ *
* <p>
* If you require an explicit replace operation, use {@link #put} instead.
*
@Test
public void hashCodeTest() {
- assertEquals("hashCode", TEST_IDENTIFIER1.hashCode(), DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.create(TestDataObject1.class)).hashCode());
+ assertEquals("hashCode", TEST_IDENTIFIER1.hashCode(), DataTreeIdentifier.create(
+ LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(TestDataObject1.class)).hashCode());
assertNotEquals("hashCode", TEST_IDENTIFIER1.hashCode(), TEST_IDENTIFIER2.hashCode());
}
Code Review / mdsal.git / commitdiff