下面列出了怎么用org.junit.experimental.theories.Theory的API类实例代码及写法，或者点击链接到github查看源代码。
@Theory
public void junit_vintage_theory_annotation_should_be_found( final int count ) throws Exception {
final String expectedClassName = getClass().getName();
final String expectedMethodName = "junit_vintage_theory_annotation_should_be_found";
final TestCaseAnnotationType expectedType = TestCaseAnnotationType.REPEATABLE;
final int expectedInvocationCount = count;
final Optional<String> actualClassName = TestCaseFinder.getInstance().findTestCaseClassNameInStack();
assertThat( actualClassName ).hasValue( expectedClassName );
final Optional<String> actualMethodName = TestCaseFinder.getInstance().findTestCaseMethodNameInStack();
assertThat( actualMethodName ).hasValueSatisfying( methodName -> methodName.startsWith( expectedMethodName ) );
final TestCaseInformation info = TestCaseFinder.getInstance().findTestCaseMethodInStack();
assertThat( info.getStackTraceElement().getClassName() ).isEqualTo( expectedClassName );
assertThat( info.getStackTraceElement().getMethodName() ).isEqualTo( expectedMethodName );
assertThat( info.getTestCaseAnnotationType() ).isEqualTo( expectedType );
assertThat( info.getInvocationCount() ).isEqualTo( expectedInvocationCount );
}
@Theory
public void applyVariableChange_should_return_same_attribute_type( final Attribute attribute ) {
if ( attribute instanceof ParameterizedAttribute ) {
final ParameterizedAttribute param = (ParameterizedAttribute) attribute;
final ParameterizedAttribute changed1 = param.applyVariableChange( "new-variable" );
assertThat( changed1 ).hasSameClassAs( attribute );
assertThat( changed1.getVariableName() ).isEqualTo( "new-variable" );
assertThat( changed1.getValue() ).isEqualTo( param.getValue() );
final ParameterizedAttribute changed2 =
(ParameterizedAttribute) changed1.applyChanges( valueChange.get( attribute ) );
assertThat( changed2.getVariableName() ).isEqualTo( changed1.getVariableName() );
}
}
@Theory
public void emptyParams(String badValue) {
// setup
formParams.replace(CLIENT_NAME, Arrays.asList(badValue));
formParams.replace(SPACE_NAME, Arrays.asList(badValue));
formParams.replace(WORK_BUNDLE_ID, Arrays.asList(badValue));
formParams.replace(WORK_BUNDLE_STATUS, Arrays.asList(badValue));
// test
final Response response = target(WORK_BUNDLE_COMPLETED_ACTION).request().post(Entity.form(formParams));
// verify
final int status = response.getStatus();
assertThat(status, equalTo(500));
final String result = response.readEntity(String.class);
assertThat(result.startsWith("Bad params:"), equalTo(true));
}
@Theory
public void badParamValues(String badValue) {
// setup
formParams.replace(DIRECTORY_NAME, Arrays.asList(badValue));
formParams.replace(TARGET_DIRECTORY, Arrays.asList(badValue));
// test
Response response = target(REGISTER_PEER_ACTION).request().post(Entity.form(formParams));
// verify
final int status = response.getStatus();
assertThat(status, equalTo(500));
final String result = response.readEntity(String.class);
assertThat(result.startsWith("Bad Params: "), equalTo(true));
}
@Theory
public void testCreatePlaceBadParams(String badParam) {
// This causes 500 errors because we are posting with empty required parameters
// setup
formParams = new MultivaluedHashMap<>();
formParams.put(CP_DIRECTORY, Arrays.asList(badParam));
formParams.put(CP_LOCATION, Arrays.asList(badParam));
formParams.put(CP_CLASS_NAME, Arrays.asList(badParam));
// test
Response response = target(CREATE_PLACE_ACTION).request().post(Entity.form(formParams));
// verify
final int status = response.getStatus();
assertThat(status, equalTo(500));
final String result = response.readEntity(String.class);
assertThat(result, equalTo(CreatePlaceAction.EMPTY_PARAM_MSG));
}
@Theory
public void verifyExpectedOptions(@FromDataPoints("ProjectBase Options") String baseDirArg, @FromDataPoints("Input Options") String inputDirArg,
@FromDataPoints("String Options") String stringArg, @FromDataPoints("Boolean Options") String booleanArg,
@FromDataPoints("Int Options") String intArg) throws Exception {
// setup
arguments.add(baseDirArg);
arguments.add(baseDir.toString());
arguments.add(inputDirArg);
arguments.add(inputDir.toString());
arguments.add(stringArg);
arguments.add("validateStringArg");
arguments.add(booleanArg);
arguments.add(intArg);
arguments.add("4");
// verify (no exceptions thrown)
FeedCommand.parse(FeedCommand.class, arguments);
}
@Test
@Theory
public void assetModule_withSdkConstraint_throws(
@FromDataPoints("sdkMutators") ManifestMutator sdkMutator) throws Exception {
BundleModule module =
new BundleModuleBuilder("asset_module")
.setManifest(androidManifestForAssetModule("com.test.app", sdkMutator))
.build();
InvalidBundleException exception =
assertThrows(
InvalidBundleException.class,
() -> new AndroidManifestValidator().validateModule(module));
assertThat(exception)
.hasMessageThat()
.matches("Unexpected element declaration in manifest of asset pack 'asset_module'.");
}
@Test
@Theory
public void badDensityDevice_throws(@FromDataPoints("apksInDirectory") boolean apksInDirectory)
throws Exception {
Path apksFile =
createApks(createSimpleTableOfContent(ZipPath.create("base-master.apk")), apksInDirectory);
DeviceSpec deviceSpec =
mergeSpecs(sdkVersion(21), density(-1), abis("x86_64", "x86"), locales("en-US"));
FakeDevice fakeDevice = FakeDevice.fromDeviceSpec(DEVICE_ID, DeviceState.ONLINE, deviceSpec);
AdbServer adbServer =
new FakeAdbServer(/* hasInitialDeviceList= */ true, ImmutableList.of(fakeDevice));
InstallApksCommand command =
InstallApksCommand.builder()
.setApksArchivePath(apksFile)
.setAdbPath(adbPath)
.setAdbServer(adbServer)
.build();
Throwable exception = assertThrows(IllegalStateException.class, () -> command.execute());
assertThat(exception).hasMessageThat().contains("Error retrieving device density");
}
@Test
@Theory
public void badAbisDevice_throws(@FromDataPoints("apksInDirectory") boolean apksInDirectory)
throws Exception {
Path apksFile =
createApks(createSimpleTableOfContent(ZipPath.create("base-master.apk")), apksInDirectory);
DeviceSpec deviceSpec = mergeSpecs(sdkVersion(21), density(480), abis(), locales("en-US"));
FakeDevice fakeDevice = FakeDevice.fromDeviceSpec(DEVICE_ID, DeviceState.ONLINE, deviceSpec);
AdbServer adbServer =
new FakeAdbServer(/* hasInitialDeviceList= */ true, ImmutableList.of(fakeDevice));
InstallApksCommand command =
InstallApksCommand.builder()
.setApksArchivePath(apksFile)
.setAdbPath(adbPath)
.setAdbServer(adbServer)
.build();
Throwable exception = assertThrows(IllegalStateException.class, () -> command.execute());
assertThat(exception).hasMessageThat().contains("Error retrieving device ABIs");
}
@Test
@Theory
public void deviceSpec_systemApkMode_withoutDeviceSpec_throws(
@FromDataPoints("systemApkBuildModes") ApkBuildMode systemApkBuildMode) throws Exception {
AppBundle appBundle =
new AppBundleBuilder()
.addModule("base", module -> module.setManifest(androidManifest("com.app")))
.build();
bundleSerializer.writeToDisk(appBundle, bundlePath);
BuildApksCommand.Builder command =
BuildApksCommand.builder()
.setBundlePath(bundlePath)
.setOutputFile(outputFilePath)
.setApkBuildMode(systemApkBuildMode);
Throwable exception = assertThrows(InvalidCommandException.class, command::build);
assertThat(exception)
.hasMessageThat()
.contains(
"Device spec must always be set when running with 'system' or 'system_compressed' "
+ "mode flag.");
}
@Test
@Theory
public void deviceSpec_systemApkMode_partialDeviceSpecWithAbiAndScreenDensity_succeeds(
@FromDataPoints("systemApkBuildModes") ApkBuildMode systemApkBuildMode) throws Exception {
DeviceSpec deviceSpec = mergeSpecs(abis("arm64-v8a"), density(DensityAlias.MDPI));
AppBundle appBundle =
new AppBundleBuilder()
.addModule("base", module -> module.setManifest(androidManifest("com.app")))
.build();
bundleSerializer.writeToDisk(appBundle, bundlePath);
BuildApksCommand.Builder command =
BuildApksCommand.builder()
.setBundlePath(bundlePath)
.setOutputFile(outputFilePath)
.setDeviceSpec(deviceSpec)
.setApkBuildMode(systemApkBuildMode);
command.build();
}
@Test
@Theory
public void deviceSpec_systemApkMode_partialDeviceSpecMissingAbi_throws(
@FromDataPoints("systemApkBuildModes") ApkBuildMode systemApkBuildMode) throws Exception {
DeviceSpec deviceSpec = mergeSpecs(density(DensityAlias.MDPI));
AppBundle appBundle =
new AppBundleBuilder()
.addModule("base", module -> module.setManifest(androidManifest("com.app")))
.build();
bundleSerializer.writeToDisk(appBundle, bundlePath);
BuildApksCommand.Builder command =
BuildApksCommand.builder()
.setBundlePath(bundlePath)
.setOutputFile(outputFilePath)
.setDeviceSpec(deviceSpec)
.setApkBuildMode(systemApkBuildMode);
Throwable exception = assertThrows(InvalidCommandException.class, command::build);
assertThat(exception)
.hasMessageThat()
.contains(
"Device spec must have screen density and ABIs set when running with 'system' or "
+ "'system_compressed' mode flag.");
}
@Test
@Theory
public void deviceSpec_systemApkMode_partialDeviceSpecMissingDensity_throws(
@FromDataPoints("systemApkBuildModes") ApkBuildMode systemApkBuildMode) throws Exception {
DeviceSpec deviceSpec = mergeSpecs(abis("arm64-v8a"));
AppBundle appBundle =
new AppBundleBuilder()
.addModule("base", module -> module.setManifest(androidManifest("com.app")))
.build();
bundleSerializer.writeToDisk(appBundle, bundlePath);
BuildApksCommand.Builder command =
BuildApksCommand.builder()
.setBundlePath(bundlePath)
.setOutputFile(outputFilePath)
.setDeviceSpec(deviceSpec)
.setApkBuildMode(systemApkBuildMode);
Throwable exception = assertThrows(InvalidCommandException.class, command::build);
assertThat(exception)
.hasMessageThat()
.contains(
"Device spec must have screen density and ABIs set when running with 'system' or "
+ "'system_compressed' mode flag.");
}
@Test
@Theory
public void checkFlagsConstructionWithDeviceSpec(
@FromDataPoints("deviceSpecs") String deviceSpecPath) throws Exception {
DeviceSpec.Builder expectedDeviceSpecBuilder = DeviceSpec.newBuilder();
try (Reader reader = TestData.openReader(deviceSpecPath)) {
JsonFormat.parser().merge(reader, expectedDeviceSpecBuilder);
}
DeviceSpec expectedDeviceSpec = expectedDeviceSpecBuilder.build();
BuildApksResult tableOfContentsProto = BuildApksResult.getDefaultInstance();
Path apksArchiveFile =
createApksArchiveFile(tableOfContentsProto, tmpDir.resolve("bundle.apks"));
Path deviceSpecFile = copyToTempDir(deviceSpecPath);
GetSizeCommand command =
GetSizeCommand.fromFlags(
new FlagParser()
.parse(
"get-size",
"total",
"--device-spec=" + deviceSpecFile,
"--apks=" + apksArchiveFile));
assertThat(command.getDeviceSpec()).isEqualTo(expectedDeviceSpec);
}
@Theory
public void grpcJavaToGrpcJava(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming) throws Exception {
final TestServerContext server = grpcJavaServer(ErrorMode.NONE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testRequestResponse(client, server, streaming);
}
@Theory
public void grpcJavaToServiceTalk(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming) throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.NONE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testRequestResponse(client, server, streaming);
}
@Ignore("gRPC compression not supported by ServiceTalk yet")
@Theory
public void grpcJavaToServiceTalkCompressedGzip(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.NONE, ssl);
// Only gzip is supported by GRPC out of the box atm.
final CompatClient client = grpcJavaClient(server.listenAddress(), "gzip", ssl);
testRequestResponse(client, server, streaming);
}
@Theory
public void serviceTalkBlockingToServiceTalkBlocking(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = serviceTalkServerBlocking(ErrorMode.NONE, ssl);
final BlockingCompatClient client = serviceTalkClient(server.listenAddress(), ssl).asBlockingClient();
testBlockingRequestResponse(client, server, streaming);
}
@Theory
public void grpcJavaToGrpcJavaError(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming) throws Exception {
final TestServerContext server = grpcJavaServer(ErrorMode.SIMPLE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, false, streaming);
}
@Theory
public void grpcJavaToGrpcJavaErrorWithStatus(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = grpcJavaServer(ErrorMode.STATUS, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, true, streaming);
}
@Theory
public void serviceTalkToGrpcJavaError(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming) throws Exception {
final TestServerContext server = grpcJavaServer(ErrorMode.SIMPLE, ssl);
final CompatClient client = serviceTalkClient(server.listenAddress(), ssl);
testGrpcError(client, server, false, streaming);
}
@Theory
public void serviceTalkToGrpcJavaErrorWithStatus(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = grpcJavaServer(ErrorMode.STATUS, ssl);
final CompatClient client = serviceTalkClient(server.listenAddress(), ssl);
testGrpcError(client, server, true, streaming);
}
@Theory
public void grpcJavaToServiceTalkError(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming) throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.SIMPLE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, false, streaming);
}
@Theory
public void grpcJavaToServiceTalkErrorInScalarResponse(@FromDataPoints("ssl") final boolean ssl)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.SIMPLE_IN_RESPONSE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, false, false);
}
@Theory
public void grpcJavaToServiceTalkErrorInStreamingResponse(@FromDataPoints("ssl") final boolean ssl)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.SIMPLE_IN_RESPONSE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testStreamResetOnUnexpectedErrorOnServiceTalkServer(client, server);
}
@Theory
public void grpcJavaToServiceTalkErrorInResponseNoOffload(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.SIMPLE_IN_RESPONSE, ssl, noOffloadsStrategy());
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, false, streaming);
}
@Theory
public void grpcJavaToServiceTalkErrorViaServiceFilter(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.SIMPLE_IN_SERVICE_FILTER, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, false, streaming);
}
@Theory
public void grpcJavaToServiceTalkErrorViaServerFilter(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.SIMPLE_IN_SERVER_FILTER, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, false, streaming);
}
@Theory
public void grpcJavaToServiceTalkErrorWithStatus(@FromDataPoints("ssl") final boolean ssl,
@FromDataPoints("streaming") final boolean streaming)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.STATUS, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, true, streaming);
}
@Theory
public void grpcJavaToServiceTalkErrorWithStatusInScalarResponse(@FromDataPoints("ssl") final boolean ssl)
throws Exception {
final TestServerContext server = serviceTalkServer(ErrorMode.STATUS_IN_RESPONSE, ssl);
final CompatClient client = grpcJavaClient(server.listenAddress(), null, ssl);
testGrpcError(client, server, true, false);
}