下面列出了怎么用org.junit.experimental.categories.Category的API类实例代码及写法,或者点击链接到github查看源代码。
@Test
@Category({ValidatesRunner.class, UsesCustomWindowMerging.class})
public void testMergingCustomWindowsKeyedCollection() {
Instant startInstant = new Instant(0L);
PCollection<KV<Integer, String>> inputCollection =
pipeline.apply(
Create.timestamped(
TimestampedValue.of(
KV.of(0, "big"), startInstant.plus(Duration.standardSeconds(10))),
TimestampedValue.of(
KV.of(1, "small1"), startInstant.plus(Duration.standardSeconds(20))),
// This element is not contained within the bigWindow and not merged
TimestampedValue.of(
KV.of(2, "small2"), startInstant.plus(Duration.standardSeconds(39)))));
PCollection<KV<Integer, String>> windowedCollection =
inputCollection.apply(Window.into(new CustomWindowFn<>()));
PCollection<Long> count =
windowedCollection.apply(
Combine.globally(Count.<KV<Integer, String>>combineFn()).withoutDefaults());
// "small1" and "big" elements merged into bigWindow "small2" not merged
// because it is not contained in bigWindow
PAssert.that("Wrong number of elements in output collection", count).containsInAnyOrder(2L, 1L);
pipeline.run();
}
@Test
@Category(IntegrationTest.class)
public void expressionIncompletePathInput1() throws Exception
{
// test expressions with file names mixed in with fullpaths
if (GEN_BASELINE_DATA_ONLY)
{
testUtils.generateBaselineTif(this.conf, testname.getMethodName(),
String.format("a = [%s]; b = 3; a / [%s] + b", allones, allonesPath), -9999);
}
else
{
testUtils.runRasterExpression(this.conf, testname.getMethodName(),
TestUtils.nanTranslatorToMinus9999, TestUtils.nanTranslatorToMinus9999,
String.format("a = [%s]; b = 3; a / [%s] + b", allones, allonesPath));
}
}
@Test
@Category(IntegrationTest.class)
public void testGetMapTifNonExistingZoomLevelAboveWithoutPyramidsExtraMetadata() throws Exception
{
String contentType = "image/tiff";
Response response = target("wms")
.queryParam("SERVICE", "WMS")
.queryParam("REQUEST", "getmap")
.queryParam("LAYERS", "IslandsElevation-v2-no-pyramid-extra-metadata")
.queryParam("FORMAT", contentType)
//pyramid only has a single zoom level = 10; pass in zoom level = 8
.queryParam("BBOX", ISLANDS_ELEVATION_V2_IN_BOUNDS_SINGLE_SOURCE_TILE)
.queryParam("WIDTH", MrGeoConstants.MRGEO_MRS_TILESIZE_DEFAULT)
.queryParam("HEIGHT", MrGeoConstants.MRGEO_MRS_TILESIZE_DEFAULT)
.request().get();
processImageResponse(response, contentType, "tif");
}
@Test
@Category(IntegrationTest.class)
public void renameFileSucceeds() {
BoxAPIConnection api = new BoxAPIConnection(TestConfig.getAccessToken());
BoxFolder rootFolder = BoxFolder.getRootFolder(api);
String originalFileName = "[renameFileSucceeds] Original Name.txt";
String newFileName = "[renameFileSucceeds] New Name.txt";
String fileContent = "Test file";
byte[] fileBytes = fileContent.getBytes(StandardCharsets.UTF_8);
InputStream uploadStream = new ByteArrayInputStream(fileBytes);
BoxFile.Info uploadedFileInfo = rootFolder.uploadFile(uploadStream, originalFileName);
BoxFile uploadedFile = uploadedFileInfo.getResource();
uploadedFile.rename(newFileName);
BoxFile.Info newInfo = uploadedFile.getInfo();
assertThat(newInfo.getName(), is(equalTo(newFileName)));
uploadedFile.delete();
}
@Test
@Category(IntegrationTest.class)
public void testGetMapLowerCaseParams() throws Exception
{
String contentType = "image/png";
Response response = target("wms")
.queryParam("SERVICE", "WMS")
.queryParam("request", "getmap")
.queryParam("layers", "IslandsElevation-v2")
.queryParam("format", contentType)
.queryParam("bbox", ISLANDS_ELEVATION_V2_IN_BOUNDS_SINGLE_SOURCE_TILE)
.queryParam("width", MrGeoConstants.MRGEO_MRS_TILESIZE_DEFAULT)
.queryParam("height", MrGeoConstants.MRGEO_MRS_TILESIZE_DEFAULT)
.request().get();
processImageResponse(response, contentType, "png");
response.close();
}
@Test
@Category(IntegrationTest.class)
public void testGetMosaicTifMultipleSourceTiles() throws Exception
{
String contentType = "image/tiff";
Response response = target("wms")
.queryParam("SERVICE", "WMS")
.queryParam("REQUEST", "getmosaic")
.queryParam("LAYERS", "IslandsElevation-v2")
.queryParam("FORMAT", contentType)
.queryParam("BBOX", ISLANDS_ELEVATION_V2_IN_BOUNDS_MULTIPLE_SOURCE_TILES)
.request().get();
processImageResponse(response, contentType, "tif");
}
@Test
@Category(NeedsRunner.class)
public void testToStringKVWithDelimiter() {
ArrayList<KV<String, Integer>> kvs = new ArrayList<>();
kvs.add(KV.of("one", 1));
kvs.add(KV.of("two", 2));
ArrayList<String> expected = new ArrayList<>();
expected.add("one\t1");
expected.add("two\t2");
PCollection<KV<String, Integer>> input = p.apply(Create.of(kvs));
PCollection<String> output = input.apply(ToString.kvs("\t"));
PAssert.that(output).containsInAnyOrder(expected);
p.run();
}
@Test
@Category(UnitTest.class)
public void testAddClassification() throws IOException {
String result = "";
final String fileID = "12345";
final String classificationType = "Public";
final String metadataURL = "/files/" + fileID + "/metadata/enterprise/securityClassification-6VMVochwUWo";
JsonObject metadataObject = new JsonObject()
.add("Box__Security__Classification__Key", classificationType);
result = TestConfig.getFixture("BoxFile/CreateClassificationOnFile201");
WIRE_MOCK_CLASS_RULE.stubFor(WireMock.post(WireMock.urlPathEqualTo(metadataURL))
.withRequestBody(WireMock.equalToJson(metadataObject.toString()))
.willReturn(WireMock.aResponse()
.withHeader("Content-Type", "application/json")
.withBody(result)));
BoxFile file = new BoxFile(this.api, fileID);
String classification = file.addClassification(classificationType);
Assert.assertEquals(classificationType, classification);
}
@Test
@Category(org.openRealmOfStars.UnitTest.class)
public void testVotingSupportRulerOfGalaxySelf() {
PlayerInfo info = Mockito.mock(PlayerInfo.class);
Mockito.when(info.getAttitude()).thenReturn(Attitude.AGGRESSIVE);
Mockito.when(info.getRace()).thenReturn(SpaceRace.HUMAN);
Diplomacy diplomacy = Mockito.mock(Diplomacy.class);
Mockito.when(info.getDiplomacy()).thenReturn(diplomacy);
Mockito.when(diplomacy.getLiking(0)).thenReturn(Diplomacy.FRIENDS);
Mockito.when(diplomacy.getLiking(5)).thenReturn(Diplomacy.HATE);
Vote vote = new Vote(VotingType.RULER_OF_GALAXY, 6, 20);
vote.setOrganizerIndex(1);
vote.setSecondCandidateIndex(5);
StarMap map = Mockito.mock(StarMap.class);
PlayerList playerList = Mockito.mock(PlayerList.class);
Mockito.when(map.getPlayerList()).thenReturn(playerList);
Mockito.when(playerList.getIndex(info)).thenReturn(1);
Mockito.when(playerList.getCurrentMaxRealms()).thenReturn(6);
assertEquals(90, StarMapUtilities.getVotingSupport(info, vote, map));
vote.setOrganizerIndex(0);
vote.setSecondCandidateIndex(1);
assertEquals(-70, StarMapUtilities.getVotingSupport(info, vote, map));
}
@Category(SlowTests.class)
@Ignore("#1522 - GND tests not running")
@Test
public void testWithLabelContainingAnyOf_Fuseki_FTS() throws Exception
{
assertIsReachable(zbwGnd);
kb.setType(REMOTE);
kb.setFullTextSearchIri(FTS_FUSEKI);
kb.setLabelIri(RDFS.LABEL);
kb.setSubPropertyIri(RDFS.SUBPROPERTYOF);
List<KBHandle> results = asHandles(zbwGnd, SPARQLQueryBuilder
.forItems(kb)
.withLabelContainingAnyOf("Schapiro-Frisch", "Stiker-Métral"));
assertThat(results).extracting(KBHandle::getIdentifier).doesNotHaveDuplicates();
assertThat(results).isNotEmpty();
assertThat(results).extracting(KBHandle::getUiLabel)
.allMatch(label -> label.contains("Schapiro-Frisch") ||
label.contains("Stiker-Métral"));
}
@Test
@Category(UnitTest.class)
public void testGetTileMapMercator() throws Exception
{
String version = "1.0.0";
when(request.getRequestURL())
.thenReturn(new StringBuffer("http://localhost:9998/tms/1.0.0/" +
rgbsmall_nopyramids_abs + "/global-mercator"));
when(service.getMetadata(rgbsmall_nopyramids_abs))
.thenReturn(getMetadata(rgbsmall_nopyramids_abs));
Response response = target("tms" + "/" + version + "/" +
URLEncoder.encode(rgbsmall_nopyramids_abs, "UTF-8") + "/global-mercator")
.request().get();
Assert.assertEquals(Status.OK.getStatusCode(), response.getStatus());
verify(request, times(1)).getRequestURL();
verify(service, times(1)).getMetadata(rgbsmall_nopyramids_abs);
verify(service, times(0));
service.listImages();
verifyNoMoreInteractions(request, service);
}
@Test
@Category(org.openRealmOfStars.UnitTest.class)
public void testCorrectOrderSkipIndexes() {
TutorialList list = new TutorialList();
HelpLine line = new HelpLine(0);
list.add(line);
line = new HelpLine(2);
list.add(line);
line = new HelpLine(4);
list.add(line);
line = new HelpLine(6);
list.add(line);
line = new HelpLine(8);
list.add(line);
assertEquals("0: - \n" +
"2: - \n" +
"4: - \n" +
"6: - \n" +
"8: - \n", list.toString());
}
@Test
@Category(org.openRealmOfStars.UnitTest.class)
public void testPrivateer() {
Espionage espionage = Mockito.mock(Espionage.class);
PlayerInfo info = Mockito.mock(PlayerInfo.class);
Mockito.when(info.getEspionage()).thenReturn(espionage);
Coordinate coord = Mockito.mock(Coordinate.class);
Mockito.when(coord.getX()).thenReturn(10);
Mockito.when(coord.getY()).thenReturn(12);
Mockito.when(info.getSectorVisibility(coord)).thenReturn(PlayerInfo.VISIBLE);
Fleet fleet = Mockito.mock(Fleet.class);
Mockito.when(fleet.getCoordinate()).thenReturn(coord);
Mockito.when(fleet.isPrivateerFleet()).thenReturn(true);
int fleetOwnerIndex = 1;
FleetVisibility visiblity = new FleetVisibility(info, fleet, fleetOwnerIndex);
assertEquals(true, visiblity.isFleetVisible());
assertEquals(false, visiblity.isEspionageDetected());
assertEquals(false, visiblity.isRecognized());
}
@Test
@Category(org.openRealmOfStars.UnitTest.class)
public void testFleetWithTradeShip2() {
Ship ship = createTradeShip();
Fleet fleet = new Fleet(ship, 2, 3);
assertEquals(2, fleet.getCoordinate().getX());
assertEquals(3, fleet.getCoordinate().getY());
fleet.setName("Trader #1");
assertEquals("Trader #1",fleet.getName());
Coordinate tradeCoordinate = new Coordinate(15,16);
Mockito.when(ship.calculateTradeCredits((Coordinate) Mockito.any(),
(Coordinate) Mockito.any())).thenReturn(4);
assertEquals(4, fleet.calculateTrade(tradeCoordinate));
fleet.addShip(ship);
assertEquals(8, fleet.calculateTrade(tradeCoordinate));
}
@Test
@Category(IntegrationTest.class)
public void getCollaborationsSucceedsAndHandlesResponseCorrectly() {
BoxAPIConnection api = new BoxAPIConnection(TestConfig.getAccessToken());
String groupName = "[getCollaborationsSucceedsAndHandlesResponseCorrectly] Test Group";
BoxGroup group = BoxGroup.createGroup(api, groupName).getResource();
BoxCollaborator collabGroup = new BoxGroup(api, group.getID());
String folderName = "[getCollaborationsSucceedsAndHandlesResponseCorrectly] Test Folder";
BoxFolder rootFolder = BoxFolder.getRootFolder(api);
BoxFolder folder = rootFolder.createFolder(folderName).getResource();
BoxCollaboration.Info collabInfo = folder.collaborate(collabGroup, BoxCollaboration.Role.EDITOR);
Collection<BoxCollaboration.Info> collaborations = group.getCollaborations();
assertThat(collaborations, hasSize(1));
assertThat(collaborations, hasItem(
Matchers.<BoxCollaboration.Info>hasProperty("ID", equalTo(collabInfo.getID())))
);
group.delete();
folder.delete(false);
}
@Test(timeout = 5000)
@Category({UnitTest.class})
public void itUpdateAlarm() throws Exception {
AlarmServiceModel alarmResult = new AlarmServiceModel();
IAlarms alarms = mock(IAlarms.class);
AlarmsController controller = new AlarmsController(alarms);
when(alarms.update(
"1",
"open"))
.thenReturn(alarmResult);
setMockContext();
// Act
Result response = controller.patch("1");
// Assert
assertThat(response.body().isKnownEmpty(), is(false));
}
@Test
@Category(NeedsRunner.class)
public void testToEnumerable_collectNullValue() {
Schema schema = Schema.builder().addNullableField("id", fieldType).build();
RelDataType type = CalciteUtils.toCalciteRowType(schema, TYPE_FACTORY);
ImmutableList<ImmutableList<RexLiteral>> tuples =
ImmutableList.of(
ImmutableList.of(
rexBuilder.makeNullLiteral(CalciteUtils.toRelDataType(TYPE_FACTORY, fieldType))));
BeamRelNode node = new BeamValuesRel(cluster, type, tuples, null);
Enumerable<Object> enumerable = BeamEnumerableConverter.toEnumerable(options, node);
Enumerator<Object> enumerator = enumerable.enumerator();
assertTrue(enumerator.moveNext());
Object row = enumerator.current();
assertEquals(null, row);
assertFalse(enumerator.moveNext());
enumerator.close();
}
@Test
@Category(IntegrationTest.class)
public void isNull() throws Exception
{
// java.util.Properties prop = MrGeoProperties.getInstance();
// prop.setProperty(HadoopUtils.IMAGE_BASE, testUtils.getInputHdfs().toUri().toString());
if (GEN_BASELINE_DATA_ONLY)
{
testUtils.generateBaselineTif(this.conf, testname.getMethodName(),
String.format("isNull([%s])", allones), -9999);
}
else
{
testUtils.runRasterExpression(this.conf, testname.getMethodName(),
TestUtils.nanTranslatorToMinus9999, TestUtils.nanTranslatorToMinus9999,
String.format("isNull([%s])", allones));
}
}
@Test
@Category(IntegrationTest.class)
public void restoreTrashedFileWithNewNameSucceeds() {
BoxAPIConnection api = new BoxAPIConnection(TestConfig.getAccessToken());
BoxTrash trash = new BoxTrash(api);
BoxFolder rootFolder = BoxFolder.getRootFolder(api);
String fileName = "[restoreTrashedFileWithNewNameSucceeds] Trashed File.txt";
String restoredFileName = "[restoreTrashedFileWithNewNameSucceeds] Restored File.txt";
String fileContent = "Trashed file";
byte[] fileBytes = fileContent.getBytes(StandardCharsets.UTF_8);
InputStream uploadStream = new ByteArrayInputStream(fileBytes);
BoxFile uploadedFile = rootFolder.uploadFile(uploadStream, fileName).getResource();
uploadedFile.delete();
BoxFile.Info restoredFileInfo = trash.restoreFile(uploadedFile.getID(), restoredFileName, null);
assertThat(restoredFileInfo.getName(), is(equalTo(restoredFileName)));
assertThat(trash, not(hasItem(Matchers.<BoxItem.Info>hasProperty("ID", equalTo(uploadedFile.getID())))));
assertThat(rootFolder, hasItem(Matchers.<BoxItem.Info>hasProperty("ID", equalTo(uploadedFile.getID()))));
uploadedFile.delete();
}
@Test
@Category(org.openRealmOfStars.UnitTest.class)
public void testGetBestFleet2() {
StarMap map = generateMapWithPlayer(SpaceRace.SPORKS);
PlayerInfo info = Mockito.mock(PlayerInfo.class);
ArrayList<Fleet> fleets = new ArrayList<>();
Fleet fleet1 = Mockito.mock(Fleet.class);
Mockito.when(fleet1.getMilitaryValue()).thenReturn(10);
Mockito.when(fleet1.calculateFleetObsoleteValue(info)).thenReturn(1);
fleets.add(fleet1);
Fleet fleet2 = Mockito.mock(Fleet.class);
Mockito.when(fleet2.getMilitaryValue()).thenReturn(8);
Mockito.when(fleet2.calculateFleetObsoleteValue(info)).thenReturn(1);
fleets.add(fleet2);
Fleet fleet3 = Mockito.mock(Fleet.class);
Mockito.when(fleet3.getMilitaryValue()).thenReturn(15);
Mockito.when(fleet3.calculateFleetObsoleteValue(info)).thenReturn(1);
fleets.add(fleet3);
DiplomaticTrade trade = new DiplomaticTrade(map, 0, 1);
assertEquals(fleet2, trade.getTradeableFleet(info, fleets));
}
@Test(timeout = 5000)
@Category({UnitTest.class})
public void itGetsAllMessages() throws
InvalidInputException,
InvalidConfigurationException,
TimeSeriesParseException {
// Arrange
IMessages messages = mock(IMessages.class);
MessagesController controller = new MessagesController(mock(IMessages.class));
ArrayList<MessageServiceModel> msgs = new ArrayList<MessageServiceModel>() {{
add(new MessageServiceModel());
add(new MessageServiceModel());
}};
MessageListServiceModel res = new MessageListServiceModel(msgs, null);
when(messages.getList(
DateTime.now(), DateTime.now(), "asc", 0, 100, new String[0]))
.thenReturn(res);
// Act
Result response = controller.list(null, null, null, null, null, null);
// Assert
assertThat(response.body().isKnownEmpty(), is(false));
}
@Test
@Category({ DevFabricTests.class, DevStoreTests.class })
public void testAddMessage() throws StorageException {
String msgContent = UUID.randomUUID().toString();
final CloudQueueMessage message = new CloudQueueMessage(msgContent);
this.queue.addMessage(message);
VerifyAddMessageResult(message, msgContent);
CloudQueueMessage msgFromRetrieve1 = this.queue.retrieveMessage();
assertEquals(message.getMessageContentAsString(), msgContent);
assertEquals(msgFromRetrieve1.getMessageContentAsString(), msgContent);
}
@Test
@Category(NeedsRunner.class)
public void testValues() {
PCollection<KV<String, Integer>> input =
p.apply(
Create.of(Arrays.asList(TABLE))
.withCoder(KvCoder.of(StringUtf8Coder.of(), BigEndianIntegerCoder.of())));
PCollection<Integer> output = input.apply(Values.create());
PAssert.that(output).containsInAnyOrder(1, 2, 3, 4, 4);
p.run();
}
@Test
@Category(org.openRealmOfStars.BehaviourTest.class)
public void testBasic() {
Planet planet = new Planet(new Coordinate(5,5), "Test", 1, false);
BigImagePanel panel = new BigImagePanel(planet, true, "Planet view");
assertEquals(null, panel.getAnimation());
PlanetAnimation animation = Mockito.mock(PlanetAnimation.class);
panel.setAnimation(animation);
assertEquals(animation, panel.getAnimation());
PlayerInfo info = Mockito.mock(PlayerInfo.class);
panel.setPlayer(info);
assertEquals(info, panel.getPlayer());
panel.setText("Test text");
panel.setTitle("Test title");
}
@Test
@Category(IntegrationTest.class)
public void getEnterpriseEventsGmtPlus530() {
BoxAPIConnection api = new BoxAPIConnection(TestConfig.getAccessToken());
System.setProperty("user.timezone", "Asia/Calcutta");
TimeZone.setDefault(null);
Date after = new Date(0L);
Date before = new Date(System.currentTimeMillis());
EventLog events = EventLog.getEnterpriseEvents(api, after, before);
assertThat(events.getSize(), is(not(0)));
assertThat(events.getStartDate(), is(equalTo(after)));
assertThat(events.getEndDate(), is(equalTo(before)));
}
@Test
@Category(UnitTest.class)
public void testConstructionWithNoZoom() throws Exception
{
subject = createDefaultSubject(0, bounds);
Assert.assertEquals(firstPartitionTileIds[0], subject.currentKey());
}
@Test
@Category(org.openRealmOfStars.UnitTest.class)
public void testNextLeaderAi() {
PlayerInfo realm = Mockito.mock(PlayerInfo.class);
Mockito.when(realm.getGovernment()).thenReturn(GovernmentType.AI);
ArrayList<Leader> pool = new ArrayList<>();
Mockito.when(realm.getLeaderPool()).thenReturn(pool);
Leader leader = new Leader("Test Leader");
leader.setAge(18);
leader.getPerkList().add(Perk.SLOW_LEARNER);
leader.getPerkList().add(Perk.STUPID);
pool.add(leader);
Leader leader2 = new Leader("Test Leader2");
leader2.setAge(18);
leader2.getPerkList().add(Perk.SCIENTIST);
leader2.getPerkList().add(Perk.FTL_ENGINEER);
leader2.getPerkList().add(Perk.EXPLORER);
leader2.getPerkList().add(Perk.CHARISMATIC);
leader2.getPerkList().add(Perk.SCANNER_EXPERT);
leader2.getPerkList().add(Perk.CORRUPTED);
leader2.getPerkList().add(Perk.MICRO_MANAGER);
leader2.getPerkList().add(Perk.TRADER);
leader2.getPerkList().add(Perk.ACADEMIC);
leader2.getPerkList().add(Perk.MILITARISTIC);
leader2.getPerkList().add(Perk.WARLORD);
pool.add(leader2);
Leader ruler = LeaderUtility.getNextRuler(realm);
assertEquals(leader2, ruler);
}
@Category(NeedsRunner.class)
@Test
public void testDanglingPTransformNeedsRunner() throws Exception {
final PCollection<String> pCollection = pCollection(pipeline);
PAssert.that(pCollection).containsInAnyOrder(WHATEVER);
pipeline.run().waitUntilFinish();
exception.expect(TestPipeline.AbandonedNodeException.class);
exception.expectMessage(P_TRANSFORM);
// dangling PTransform
addTransform(pCollection);
}
@Test
@Category(org.openRealmOfStars.BehaviourTest.class)
public void testDeployStarbase2() {
PlayerInfo info = Mockito.mock(PlayerInfo.class);
Mission mission = new Mission(MissionType.DEPLOY_STARBASE, MissionPhase.LOADING,
new Coordinate(5, 5));
MissionList missionList = Mockito.mock(MissionList.class);
Mockito.when(missionList.getMissionForFleet(Mockito.anyString()))
.thenReturn(null);
Mockito.when(info.getMissions()).thenReturn(missionList);
Ship starbase = Mockito.mock(Ship.class);
Mockito.when(starbase.getTotalMilitaryPower()).thenReturn(20);
ShipHull hull = Mockito.mock(ShipHull.class);
Mockito.when(hull.getHullType()).thenReturn(ShipHullType.STARBASE);
Mockito.when(hull.getName()).thenReturn("Artificial planet");
Mockito.when(starbase.getHull()).thenReturn(hull);
Fleet fleet = new Fleet(starbase, 5, 5);
FleetList fleetList = new FleetList();
fleetList.add(fleet);
Mockito.when(info.getFleets()).thenReturn(fleetList);
Game game = Mockito.mock(Game.class);
Tile tile = Mockito.mock(Tile.class);
Mockito.when(tile.getName()).thenReturn(TileNames.DEEP_SPACE_ANCHOR2);
StarMap map = Mockito.mock(StarMap.class);
Mockito.when(map.getTile(Mockito.anyInt(), Mockito.anyInt())).thenReturn(tile);
Mockito.when(game.getStarMap()).thenReturn(map);
MissionHandling.handleDeployStarbase(mission, fleet, info, game);
assertEquals(MissionPhase.EXECUTING, mission.getPhase());
}
@Test
@Category({
ValidatesRunner.class,
UsesBoundedSplittableParDo.class,
DataflowPortabilityApiUnsupported.class
})
public void testOutputAfterCheckpointBounded() {
testOutputAfterCheckpoint(IsBounded.BOUNDED);
}