import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.setStatus(StartTestOutput.Status.OK)
.setListBuildTime(listCreateTime)
.setExecTime(execTime)
- .setTxOk((long)dsWriter.getTxOk())
- .setNtfOk(numEvents)
- .setDataChangeEventsOk(numDataChanges)
- .setTxError((long)dsWriter.getTxError())
+ .setTxOk(Uint32.valueOf(dsWriter.getTxOk()))
+ .setNtfOk(Uint32.valueOf(numEvents))
+ .setDataChangeEventsOk(Uint32.valueOf(numDataChanges))
+ .setTxError(Uint32.valueOf(dsWriter.getTxError()))
.build();
return RpcResultBuilder.success(output).buildFuture();
private void setTestOperData(final ExecStatus sts, final long tstCompl) {
TestStatus status = new TestStatusBuilder()
.setExecStatus(sts)
- .setTestsCompleted(tstCompl)
+ .setTestsCompleted(Uint32.valueOf(tstCompl))
.build();
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final StartTestOutput output =
new StartTestOutputBuilder()
- .setProducerElapsedTime(producerElapsedTime / 1000000)
- .setListenerElapsedTime(listenerElapsedTime / 1000000)
- .setListenerOk(allListeners)
- .setProducerOk(allProducersOk)
- .setProducerError(allProducersError)
- .setProducerRate((allProducersOk + allProducersError) * 1000000000 / producerElapsedTime)
- .setListenerRate(allListeners * 1000000000 / listenerElapsedTime)
+ .setProducerElapsedTime(Uint32.valueOf(producerElapsedTime / 1000000))
+ .setListenerElapsedTime(Uint32.valueOf(listenerElapsedTime / 1000000))
+ .setListenerOk(Uint32.valueOf(allListeners))
+ .setProducerOk(Uint32.valueOf(allProducersOk))
+ .setProducerError(Uint32.valueOf(allProducersError))
+ .setProducerRate(Uint32.valueOf((allProducersOk + allProducersError) * 1000000000
+ / producerElapsedTime))
+ .setListenerRate(Uint32.valueOf(allListeners * 1000000000 / listenerElapsedTime))
.build();
return RpcResultBuilder.success(output).buildFuture();
} finally {
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
long elapsedTime = endTime - startTime;
StartTestOutput output = new StartTestOutputBuilder()
- .setRate((long)0)
- .setGlobalRtcClientError(client.getRpcError())
- .setGlobalRtcClientOk(client.getRpcOk())
- .setExecTime(TimeUnit.NANOSECONDS.toMillis(elapsedTime))
- .setRate(
- (client.getRpcOk() + client.getRpcError()) * 1000000000 / elapsedTime)
+ .setRate(Uint32.ZERO)
+ .setGlobalRtcClientError(Uint32.valueOf(client.getRpcError()))
+ .setGlobalRtcClientOk(Uint32.valueOf(client.getRpcOk()))
+ .setExecTime(Uint32.valueOf(TimeUnit.NANOSECONDS.toMillis(elapsedTime)))
+ .setRate(Uint32.valueOf(
+ (client.getRpcOk() + client.getRpcError()) * 1000000000 / elapsedTime))
.build();
return RpcResultBuilder.success(output).buildFuture();
} finally {
public ListenableFuture<RpcResult<TestStatusOutput>> testStatus(final TestStatusInput input) {
LOG.info("testStatus");
TestStatusOutput output = new TestStatusOutputBuilder()
- .setGlobalServerCnt((long)globalServer.getNumRpcs())
+ .setGlobalServerCnt(Uint32.valueOf(globalServer.getNumRpcs()))
.setExecStatus(execStatus.get())
.build();
return RpcResultBuilder.success(output).buildFuture();
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.listener.rev150825.listener.test.ListItemBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
/**
* Regression test suite for https://bugs.opendaylight.org/show_bug.cgi?id=4513 - Change event is empty when
private ListItem writeListItem() {
WriteTransaction writeTransaction = getDataBroker().newWriteOnlyTransaction();
- final ListItem item = new ListItemBuilder().setSip("name").setOp(43L).build();
+ final ListItem item = new ListItemBuilder().setSip("name").setOp(Uint32.valueOf(43)).build();
ListenerTestBuilder builder = new ListenerTestBuilder().setListItem(Arrays.asList(item));
writeTransaction.put(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.builder(
ListenerTest.class).build(), builder.build());
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.notification.rev150205.OutOfPixieDustNotificationBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.ops4j.pax.exam.util.Filter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* covers registering of notification listener, publishing of notification and receiving of notification.
*/
public class NotificationIT extends AbstractIT {
-
- private static final Logger LOG = LoggerFactory
- .getLogger(NotificationIT.class);
+ private static final Logger LOG = LoggerFactory.getLogger(NotificationIT.class);
@Inject
@Filter(timeout = 120 * 1000)
*/
public static OutOfPixieDustNotification noDustNotification(final String reason, final int days) {
OutOfPixieDustNotificationBuilder ret = new OutOfPixieDustNotificationBuilder();
- ret.setReason(reason).setDaysTillNewDust(days);
+ ret.setReason(reason).setDaysTillNewDust(Uint16.valueOf(days));
return ret.build();
}
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
stopThread();
StopStressTestOutputBuilder stopStressTestOutput;
stopStressTestOutput = new StopStressTestOutputBuilder()
- .setSuccessCount(succcessCounter.longValue())
- .setFailureCount(failureCounter.longValue());
+ .setSuccessCount(Uint32.valueOf(succcessCounter.longValue()))
+ .setFailureCount(Uint32.valueOf(failureCounter.longValue()));
final StopStressTestOutput result = stopStressTestOutput.build();
LOG_PURCHASE_CAR.info("Executed Stop Stress test; No. of cars created {}; "
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Access the ToasterService to make the toast.
- MakeToastInput toastInput = new MakeToastInputBuilder().setToasterDoneness((long) toastDoneness)
+ MakeToastInput toastInput = new MakeToastInputBuilder().setToasterDoneness(Uint32.valueOf(toastDoneness))
.setToasterToastType(toastType).build();
return toaster.makeToast(toastInput);
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public OpendaylightToaster() {
this(new ToasterAppConfigBuilder().setManufacturer(TOASTER_MANUFACTURER).setModelNumber(TOASTER_MODEL_NUMBER)
- .setMaxMakeToastTries(2).build());
+ .setMaxMakeToastTries(Uint16.valueOf(2)).build());
}
public OpendaylightToaster(final ToasterAppConfig toasterAppConfig) {
import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.WheatBread;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class OpenDaylightToasterTest extends AbstractConcurrentDataBrokerTest {
- private static InstanceIdentifier<Toaster> TOASTER_IID = InstanceIdentifier.builder(Toaster.class).build();
+ private static final InstanceIdentifier<Toaster> TOASTER_IID = InstanceIdentifier.builder(Toaster.class).build();
private OpendaylightToaster toaster;
@Before
@Test
@Ignore //ignored because it is not a test right now. Illustrative purposes only.
public void testSomething() throws Exception {
- MakeToastInput toastInput = new MakeToastInputBuilder().setToasterDoneness(1L)
+ MakeToastInput toastInput = new MakeToastInputBuilder().setToasterDoneness(Uint32.valueOf(1))
.setToasterToastType(WheatBread.class).build();
// NOTE: In a real test we would want to override the Thread.sleep() to