下面列出了怎么用com.google.common.collect.ImmutableMap的API类实例代码及写法，或者点击链接到github查看源代码。
@Before
public final void createExecutorAndContext() throws Exception {
BinTools binTools = BinTools.forUnitTesting(directories, analysisMock.getEmbeddedTools());
executor = new TestExecutorBuilder(fileSystem, directories, binTools).build();
context =
new ActionExecutionContext(
executor,
/*actionInputFileCache=*/ null,
ActionInputPrefetcher.NONE,
actionKeyContext,
/*metadataHandler=*/ null,
/*rewindingEnabled=*/ false,
LostInputsCheck.NONE,
new FileOutErr(),
new StoredEventHandler(),
/*clientEnv=*/ ImmutableMap.of(),
/*topLevelFilesets=*/ ImmutableMap.of(),
/*artifactExpander=*/ null,
/*actionFileSystem=*/ null,
/*skyframeDepsResult=*/ null,
NestedSetExpander.DEFAULT);
}
@Test
void returnDnsQuestionsWhenAllQueryTimeout() throws Exception {
try (TestDnsServer server1 = new TestDnsServer(ImmutableMap.of(), new AlwaysTimeoutHandler());
TestDnsServer server2 = new TestDnsServer(ImmutableMap.of(), new AlwaysTimeoutHandler())) {
final EventLoop eventLoop = eventLoopExtension.get();
final DnsResolverGroupBuilder builder = builder(server1, server2)
.queryTimeoutMillis(1000)
.resolvedAddressTypes(ResolvedAddressTypes.IPV4_PREFERRED);
try (RefreshingAddressResolverGroup group = builder.build(eventLoop)) {
final AddressResolver<InetSocketAddress> resolver = group.getResolver(eventLoop);
final Future<InetSocketAddress> future = resolver.resolve(
InetSocketAddress.createUnresolved("foo.com", 36462));
await().until(future::isDone);
assertThat(future.cause()).isInstanceOf(DnsTimeoutException.class);
}
}
}
private WorkerMacroArg(
Arg arg,
BuildTarget workerTarget,
ProjectFilesystem projectFilesystem,
WorkerTool workerTool,
ImmutableList<String> startupCommand,
ImmutableMap<String, String> startupEnvironment) {
super(arg);
Preconditions.checkArgument(
workerTarget.getCell().equals(projectFilesystem.getBuckPaths().getCellName()),
"filesystem cell '%s' must match target cell: %s",
projectFilesystem.getBuckPaths().getCellName(),
workerTarget);
this.workerTarget = workerTarget;
this.projectFilesystem = projectFilesystem;
this.workerTool = workerTool;
this.startupCommand = startupCommand;
this.startupEnvironment = startupEnvironment;
}
@Test
public void compareEqualConfigs() {
RawConfig rawConfig1 =
RawConfig.builder()
.putAll(ImmutableMap.of("section", ImmutableMap.of("field", "value1")))
.putAll(ImmutableMap.of("section", ImmutableMap.of("field", "value2")))
.build();
RawConfig rawConfig2 =
RawConfig.builder()
.putAll(ImmutableMap.of("section", ImmutableMap.of("field", "value1")))
.putAll(ImmutableMap.of("section", ImmutableMap.of("field", "value2")))
.build();
assertTrue(ConfigDifference.compare(rawConfig1.getValues(), rawConfig2.getValues()).isEmpty());
}
@Override
public Map<String, String> createOptions() {
ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<String, String>();
return builder.put(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG, SORT_PARAMS_VALUE)
.put(CodegenConstants.SORT_MODEL_PROPERTIES_BY_REQUIRED_FLAG, SORT_MODEL_PROPERTIES_VALUE)
.put(CodegenConstants.ENSURE_UNIQUE_PARAMS, ENSURE_UNIQUE_PARAMS_VALUE)
.put(DartClientCodegen.BROWSER_CLIENT, BROWSER_CLIENT_VALUE)
.put(DartClientCodegen.PUB_NAME, PUB_NAME_VALUE)
.put(DartClientCodegen.PUB_VERSION, PUB_VERSION_VALUE)
.put(DartClientCodegen.PUB_DESCRIPTION, PUB_DESCRIPTION_VALUE)
.put(DartClientCodegen.PUB_AUTHOR, PUB_AUTHOR_VALUE)
.put(DartClientCodegen.PUB_AUTHOR_EMAIL, PUB_AUTHOR_EMAIL_VALUE)
.put(DartClientCodegen.PUB_HOMEPAGE, PUB_HOMEPAGE_VALUE)
.put(CodegenConstants.SOURCE_FOLDER, SOURCE_FOLDER_VALUE)
.put(DartClientCodegen.USE_ENUM_EXTENSION, USE_ENUM_EXTENSION)
.put(CodegenConstants.ALLOW_UNICODE_IDENTIFIERS, ALLOW_UNICODE_IDENTIFIERS_VALUE)
.put(CodegenConstants.PREPEND_FORM_OR_BODY_PARAMETERS, PREPEND_FORM_OR_BODY_PARAMETERS_VALUE)
.put(DartClientCodegen.SUPPORT_DART2, "false")
.put(CodegenConstants.LEGACY_DISCRIMINATOR_BEHAVIOR, "true")
.put(CodegenConstants.DISALLOW_ADDITIONAL_PROPERTIES_IF_NOT_PRESENT, "true")
.build();
}
/**
* {@inheritDoc}
*/
@Override
public PrincipalPrivilegeSet get_privilege_set(final HiveObjectRef hiveObject, final String userName,
final List<String> groupNames)
throws TException {
MetacatContextManager.getContext().setUserName(userName);
return requestWrapper("get_privilege_set", new Object[]{hiveObject, userName, groupNames},
() -> {
Map<String, List<PrivilegeGrantInfo>> groupPrivilegeSet = null;
Map<String, List<PrivilegeGrantInfo>> userPrivilegeSet = null;
if (groupNames != null) {
groupPrivilegeSet = groupNames.stream()
.collect(Collectors.toMap(p -> p, p -> Lists.newArrayList()));
}
if (userName != null) {
userPrivilegeSet = ImmutableMap.of(userName, Lists.newArrayList());
}
return new PrincipalPrivilegeSet(userPrivilegeSet,
groupPrivilegeSet,
defaultRolesPrivilegeSet);
});
}
@Test
public void initialConnectionIssues(
@DockerContainer(container = "redis") Container container,
@Port(container = "redis", internalPort = 6379) InetSocketAddress address) throws ExecutionException, InterruptedException, IOException {
log.info("address = {}", address);
final String topic = "putWrite";
SinkTaskContext context = mock(SinkTaskContext.class);
when(context.assignment()).thenReturn(ImmutableSet.of());
this.task.initialize(context);
container.stop();
ExecutorService service = Executors.newSingleThreadExecutor();
Future<?> future = service.submit(() -> task.start(
ImmutableMap.of(RedisSinkConnectorConfig.HOSTS_CONFIG, String.format("%s:%s", address.getHostString(), address.getPort())
)
));
container.start();
Time.SYSTEM.sleep(2000);
future.get();
}
@Override
public ImmutableMap<String, Schema> getSchemas() throws QuarkException {
Map<String, List<SchemaOrdinal>> schemas;
try {
schemas = getSchemaListDescribed();
} catch (ExecutionException | InterruptedException e) {
LOG.error("Getting Schema metadata for " + this.endpoint
+ " failed. Error: " + e.getMessage(), e);
throw new QuarkException(e);
}
ImmutableMap.Builder<String, Schema> schemaBuilder = new ImmutableMap.Builder<>();
for (String schemaName: schemas.keySet()) {
String schemaKey = schemaName;
if (!this.isCaseSensitive()) {
schemaKey = schemaName.toUpperCase();
}
schemaBuilder.put(schemaKey, new QuboleSchema(schemaKey,
schemas.get(schemaName), this.isCaseSensitive(), this.getDataTypes()));
}
return schemaBuilder.build();
}
@Test
public void testValid()
{
ThriftEnumMetadata<Letter> metadata = thriftEnumMetadata(Letter.class);
assertEquals(metadata.getEnumClass(), Letter.class);
assertEquals(metadata.getEnumName(), "Letter");
assertEquals(metadata.getByEnumConstant(), ImmutableMap.<Letter, Integer>builder()
.put(Letter.A, 65)
.put(Letter.B, 66)
.put(Letter.C, 67)
.put(Letter.D, 68)
.put(Letter.UNKNOWN, -1)
.build());
assertEquals(metadata.getByEnumValue(), ImmutableMap.<Integer, Letter>builder()
.put(65, Letter.A)
.put(66, Letter.B)
.put(67, Letter.C)
.put(68, Letter.D)
.put(-1, Letter.UNKNOWN)
.build());
assertEquals(metadata.getUnknownEnumConstant(), Optional.of(Letter.UNKNOWN));
}
public static void main(String[] args) throws AuthorizationException, InvocationCommandException, CommandException {
Map<String, User> users = new ImmutableMap.Builder<String, User>()
.put("aaron", new User("Aaron"))
.put("michelle", new User("Michelle"))
.build();
Namespace namespace = new Namespace();
namespace.put("sender", users.get("aaron")); // Our sender
Injector injector = Intake.createInjector();
injector.install(new SenderModule(users));
ParametricBuilder builder = new ParametricBuilder(injector);
Dispatcher dispatcher = new SimpleDispatcher();
builder.registerMethodsAsCommands(dispatcher, new SenderExample());
dispatcher.call("greet", namespace, ImmutableList.<String>of());
dispatcher.call("privmsg aaron", namespace, ImmutableList.<String>of());
dispatcher.call("privmsg michelle", namespace, ImmutableList.<String>of());
dispatcher.call("poke aaron", namespace, ImmutableList.<String>of());
dispatcher.call("poke michelle", namespace, ImmutableList.<String>of());
}
private SqlStageExecution(StageStateMachine stateMachine, RemoteTaskFactory remoteTaskFactory, NodeTaskMap nodeTaskMap, boolean summarizeTaskInfo, Executor executor, FailureDetector failureDetector)
{
this.stateMachine = stateMachine;
this.remoteTaskFactory = requireNonNull(remoteTaskFactory, "remoteTaskFactory is null");
this.nodeTaskMap = requireNonNull(nodeTaskMap, "nodeTaskMap is null");
this.summarizeTaskInfo = summarizeTaskInfo;
this.executor = requireNonNull(executor, "executor is null");
this.failureDetector = requireNonNull(failureDetector, "failureDetector is null");
ImmutableMap.Builder<PlanFragmentId, RemoteSourceNode> fragmentToExchangeSource = ImmutableMap.builder();
for (RemoteSourceNode remoteSourceNode : stateMachine.getFragment().getRemoteSourceNodes()) {
for (PlanFragmentId planFragmentId : remoteSourceNode.getSourceFragmentIds()) {
fragmentToExchangeSource.put(planFragmentId, remoteSourceNode);
}
}
this.exchangeSources = fragmentToExchangeSource.build();
}
@Override
public Page<ProgrammingSubmission> getPageOfProgrammingSubmissions(long pageIndex, long pageSize, String orderBy, String orderDir, String authorJid, String problemJid, String containerJid) {
ImmutableMap.Builder<SingularAttribute<? super SM, ? extends Object>, String> filterColumnsBuilder = ImmutableMap.builder();
if (authorJid != null) {
filterColumnsBuilder.put(AbstractProgrammingSubmissionModel_.createdBy, authorJid);
}
if (problemJid != null) {
filterColumnsBuilder.put(AbstractProgrammingSubmissionModel_.problemJid, problemJid);
}
if (containerJid != null) {
filterColumnsBuilder.put(AbstractProgrammingSubmissionModel_.containerJid, containerJid);
}
Map<SingularAttribute<? super SM, ? extends Object>, String> filterColumns = filterColumnsBuilder.build();
long totalRowsCount = programmingSubmissionDao.countByFiltersEq("", filterColumns);
List<SM> submissionModels = programmingSubmissionDao.findSortedByFiltersEq(orderBy, orderDir, "", filterColumns, pageIndex * pageSize, pageSize);
Map<String, List<GM>> gradingModelsMap = programmingGradingDao.getBySubmissionJids(Lists.transform(submissionModels, m -> m.jid));
List<ProgrammingSubmission> submissions = Lists.transform(submissionModels, m -> ProgrammingSubmissionServiceUtils.createSubmissionFromModels(m, gradingModelsMap.get(m.jid)));
return new Page<>(submissions, totalRowsCount, pageIndex, pageSize);
}
@Test
public void testNdkAppPlatformPriority() {
ImmutableMap<String, String> ndkSection =
new ImmutableMap.Builder<String, String>()
.put("app_platform", "fallback")
.put("app_platform_per_cpu_abi", "arm64 => specific")
.build();
AndroidBuckConfig androidBuckConfig = makeAndroidBuckConfig(ndkSection);
// Make sure we have an fallback value.
assertEquals(androidBuckConfig.getNdkCpuAbiFallbackAppPlatform(), Optional.of("fallback"));
// Make sure ABI-specific values override the fallback one.
assertEquals(androidBuckConfig.getNdkAppPlatformForCpuAbi("arm64"), Optional.of("specific"));
// Make sure we default to fallback.
assertEquals(androidBuckConfig.getNdkAppPlatformForCpuAbi("fake"), Optional.of("fallback"));
}
@Test
public void testDistributedSort()
{
ImmutableList<PlanMatchPattern.Ordering> orderBy = ImmutableList.of(sort("ORDERKEY", DESCENDING, LAST));
assertDistributedPlan(
"SELECT orderkey FROM orders ORDER BY orderkey DESC",
output(
exchange(REMOTE, GATHER, orderBy,
exchange(LOCAL, GATHER, orderBy,
sort(orderBy,
exchange(REMOTE, REPARTITION,
tableScan("orders", ImmutableMap.of(
"ORDERKEY", "orderkey"))))))));
assertDistributedPlan(
"SELECT orderkey FROM orders ORDER BY orderkey DESC",
Session.builder(this.getQueryRunner().getDefaultSession())
.setSystemProperty(DISTRIBUTED_SORT, Boolean.toString(false))
.build(),
output(
sort(orderBy,
exchange(LOCAL, GATHER,
exchange(REMOTE, GATHER,
tableScan("orders", ImmutableMap.of(
"ORDERKEY", "orderkey")))))));
}
@Test
public void testGetTokenNoRefresh() throws IOException, InterruptedException {
MockGoogleCredentials credentials = new MockGoogleCredentials("mock-token");
TokenRefreshDetector refreshDetector = new TokenRefreshDetector();
credentials.addChangeListener(refreshDetector);
credentials.refresh();
assertEquals(1, refreshDetector.count);
FirebaseOptions options = new FirebaseOptions.Builder()
.setCredentials(credentials)
.build();
FirebaseApp app = FirebaseApp.initializeApp(options);
JvmAuthTokenProvider provider = new JvmAuthTokenProvider(app, DIRECT_EXECUTOR);
TestGetTokenListener listener = new TestGetTokenListener();
provider.getToken(false, listener);
assertToken(listener.get(), "mock-token", ImmutableMap.<String, Object>of());
assertEquals(1, refreshDetector.count);
}
@Test
public void testDereferencePushdownUnnest()
{
assertPlan("WITH t(msg, array) AS (VALUES ROW(CAST(ROW(1, 2.0) AS ROW(x BIGINT, y DOUBLE)), ARRAY[1, 2, 3])) " +
"SELECT a.msg.x " +
"FROM t a JOIN t b ON a.msg.y = b.msg.y " +
"CROSS JOIN UNNEST (a.array) " +
"WHERE a.msg.x + b.msg.x < BIGINT '10'",
output(ImmutableList.of("expr"),
strictProject(ImmutableMap.of("expr", expression("a_x")),
unnest(
join(INNER, ImmutableList.of(equiJoinClause("a_y", "b_y")),
Optional.of("a_x + b_x < BIGINT '10'"),
anyTree(
strictProject(ImmutableMap.of("a_y", expression("msg.y"), "a_x", expression("msg.x"), "a_z", expression("array")),
values("msg", "array"))),
anyTree(
strictProject(ImmutableMap.of("b_y", expression("msg.y"), "b_x", expression("msg.x")),
values("msg"))))))));
}
@Test
public void testCreateSchema()
{
assertEquals(metadata.listSchemaNames(SESSION), ImmutableList.of("default"));
metadata.createSchema(SESSION, "test", ImmutableMap.of(), new PrestoPrincipal(USER, SESSION.getUser()));
assertEquals(metadata.listSchemaNames(SESSION), ImmutableList.of("default", "test"));
assertEquals(metadata.listTables(SESSION, Optional.of("test")), ImmutableList.of());
SchemaTableName tableName = new SchemaTableName("test", "first_table");
metadata.createTable(
SESSION,
new ConnectorTableMetadata(
tableName,
ImmutableList.of(),
ImmutableMap.of()),
false);
assertEquals(metadata.listTables(SESSION, Optional.empty()), ImmutableList.of(tableName));
assertEquals(metadata.listTables(SESSION, Optional.of("test")), ImmutableList.of(tableName));
assertEquals(metadata.listTables(SESSION, Optional.of("default")), ImmutableList.of());
}
private void sendInvite(final Player player, final Faction playerFaction, final Faction targetFaction) throws CommandException
{
final AllyRequest invite = new AllyRequest(playerFaction.getName(), targetFaction.getName());
if(EagleFactionsPlugin.TRUCE_INVITE_LIST.contains(invite))
throw new CommandException(Text.of(PluginInfo.ERROR_PREFIX, Messages.YOU_HAVE_ALREADY_INVITED_THIS_FACTION_TO_THE_TRUCE));
EagleFactionsPlugin.TRUCE_INVITE_LIST.add(invite);
final Optional<Player> optionalInvitedFactionLeader = super.getPlugin().getPlayerManager().getPlayer(targetFaction.getLeader());
optionalInvitedFactionLeader.ifPresent(x-> optionalInvitedFactionLeader.get().sendMessage(getInviteGetMessage(playerFaction)));
targetFaction.getOfficers().forEach(x-> super.getPlugin().getPlayerManager().getPlayer(x).ifPresent(y-> getInviteGetMessage(playerFaction)));
player.sendMessage(Text.of(PluginInfo.PLUGIN_PREFIX, MessageLoader.parseMessage(Messages.YOU_HAVE_INVITED_FACTION_TO_THE_TRUCE, TextColors.GREEN, ImmutableMap.of(Placeholders.FACTION_NAME, Text.of(TextColors.GOLD, targetFaction.getName())))));
final Task.Builder taskBuilder = Sponge.getScheduler().createTaskBuilder();
taskBuilder.execute(() -> EagleFactionsPlugin.TRUCE_INVITE_LIST.remove(invite)).delay(2, TimeUnit.MINUTES).name("EagleFaction - Remove Invite").submit(super.getPlugin());
}
@Test
public void testResultHasCxxLibraryValueTakenFromPlatformCxxflags() {
CxxPlatform platform =
CxxPlatform.builder()
.from(DEFAULT_PLATFORM)
.setCxxflags(StringArg.from(ImmutableList.of("-stdlib=somevalue")))
.build();
ImmutableMap<String, ImmutableMap<String, String>> buildConfigs =
CxxPlatformXcodeConfigGenerator.getDefaultXcodeBuildConfigurationsFromCxxPlatform(
platform, new LinkedHashMap<>(), DEFAULT_PATH_RESOLVER);
ImmutableMap<String, String> config =
buildConfigs.get(CxxPlatformXcodeConfigGenerator.DEBUG_BUILD_CONFIGURATION_NAME);
assertThat(
config.get(CxxPlatformXcodeConfigGenerator.CLANG_CXX_LIBRARY),
Matchers.equalTo("somevalue"));
}
@Override
protected Iterable<IdentityProviderMapperRepresentation> createIdentityProviderMappers(IdentityProviderMapperSyncMode syncMode) {
IdentityProviderMapperRepresentation attrMapper1 = new IdentityProviderMapperRepresentation();
attrMapper1.setName("manager-role-mapper");
attrMapper1.setIdentityProviderMapper(ExternalKeycloakRoleToRoleMapper.PROVIDER_ID);
attrMapper1.setConfig(ImmutableMap.<String,String>builder()
.put(IdentityProviderMapperModel.SYNC_MODE, syncMode.toString())
.put("external.role", ROLE_MANAGER)
.put("role", ROLE_MANAGER)
.build());
IdentityProviderMapperRepresentation attrMapper2 = new IdentityProviderMapperRepresentation();
attrMapper2.setName("user-role-mapper");
attrMapper2.setIdentityProviderMapper(ExternalKeycloakRoleToRoleMapper.PROVIDER_ID);
attrMapper2.setConfig(ImmutableMap.<String,String>builder()
.put(IdentityProviderMapperModel.SYNC_MODE, syncMode.toString())
.put("external.role", ROLE_USER)
.put("role", ROLE_USER)
.build());
return Lists.newArrayList(attrMapper1, attrMapper2);
}
@Test
public void testMetadataIsWrittenWhenCreatingEmptyObjects() throws IOException {
String bucketName = getSharedBucketName();
Map<String, byte[]> metadata =
ImmutableMap.of(
"key1", "value1".getBytes(StandardCharsets.UTF_8),
"key2", "value2".getBytes(StandardCharsets.UTF_8));
// Verify the bucket exist by creating an object
StorageResourceId objectToCreate =
new StorageResourceId(bucketName, "testMetadataIsWrittenWhenCreatingEmptyObjects_Object");
rawStorage.createEmptyObject(objectToCreate, new CreateObjectOptions(false, metadata));
// Verify we get metadata from getItemInfo
GoogleCloudStorageItemInfo itemInfo = rawStorage.getItemInfo(objectToCreate);
assertMapsEqual(metadata, itemInfo.getMetadata(), BYTE_ARRAY_EQUIVALENCE);
}
@Test
public void testSimpleValueType() {
final String happy = "happy";
final int testInt = 23;
final Map<String, Long> testMap = ImmutableMap.of("happy", 23L);
SimpleValueType simple = SimpleValueType.create(happy, testInt, testMap);
assertSame(happy, simple.string());
assertEquals(testInt, simple.integer());
assertSame(testMap, simple.map());
assertEquals("SimpleValueType{string=happy, integer=23, map={happy=23}}", simple.toString());
int expectedHashCode = 1;
expectedHashCode = (expectedHashCode * 1000003) ^ happy.hashCode();
expectedHashCode = (expectedHashCode * 1000003) ^ ((Object) testInt).hashCode();
expectedHashCode = (expectedHashCode * 1000003) ^ testMap.hashCode();
assertEquals(expectedHashCode, simple.hashCode());
}
private void compileParameters(AnnotatedType[] annotatedParameterTypes, Annotation[][] annotations) {
ImmutableList.Builder<String> parameterOrderBuilder = ImmutableList.builder();
ImmutableMap.Builder<String, Type> nameToTypeBuilder = ImmutableMap.builder();
for (int x = 0; x < annotatedParameterTypes.length; ++x) {
AnnotatedType annotatedType = annotatedParameterTypes[x];
PathParam pathParam = getPathParam(annotations[x]);
String name;
Type type;
if (pathParam != null) {
name = pathParam.value();
type = annotatedType.getType();
} else {
name = NAME_ENTITY;
type = annotatedType.getType();
}
parameterOrderBuilder.add(name);
nameToTypeBuilder.put(name, type);
}
parameterOrder = parameterOrderBuilder.build();
parameterNameToType = nameToTypeBuilder.build();
}
@Test
public void testRepartitionedJoinWithExchange()
{
TableScanNode ts1 = tableScan("ts1", "orderkey");
TableScanNode ts2 = tableScan("ts2", "orderkey_0");
ExchangeNode remoteExchange1 = partitionedExchange(new PlanNodeId("re1"), REMOTE, ts1, ImmutableList.of(new Symbol("orderkey")), Optional.empty());
ExchangeNode remoteExchange2 = partitionedExchange(new PlanNodeId("re2"), REMOTE, ts2, ImmutableList.of(new Symbol("orderkey_0")), Optional.empty());
ExchangeNode localExchange = partitionedExchange(new PlanNodeId("le"), LOCAL, remoteExchange2, ImmutableList.of(new Symbol("orderkey_0")), Optional.empty());
JoinNode join = join("join",
remoteExchange1,
localExchange,
JoinNode.DistributionType.PARTITIONED,
"orderkey",
"orderkey_0");
Map<String, PlanNodeStatsEstimate> stats = ImmutableMap.<String, PlanNodeStatsEstimate>builder()
.put("join", statsEstimate(join, 12000))
.put("re1", statsEstimate(remoteExchange1, 10000))
.put("re2", statsEstimate(remoteExchange2, 10000))
.put("le", statsEstimate(localExchange, 6000))
.put("ts1", statsEstimate(ts1, 6000))
.put("ts2", statsEstimate(ts2, 1000))
.build();
Map<String, Type> types = ImmutableMap.of(
"orderkey", BIGINT,
"orderkey_0", BIGINT);
assertFragmentedEqualsUnfragmented(join, stats, types);
}
@Test
public void shouldNotRunScriptAutomaticallyOnCommandFailureIfNotEnabledForCommand(
EndToEndTestDescriptor test, EndToEndWorkspace workspace) throws Exception {
workspace.addBuckConfigLocalOptions(
ImmutableMap.of(
"fix",
ImmutableMap.of(
"fix_script",
fixPyCommand(),
"fix_script_contact",
"[email protected]",
"fix_script_message",
"Running {command}; contact {contact}",
"autofix_enabled",
"ALWAYS",
"autofix_commands",
"test")));
ProcessResult result = buckCommand(workspace, test, "build", "//:foo");
result.assertExitCode(ExitCode.PARSE_ERROR);
assertThat(
result.getStderr(),
Matchers.not(
Matchers.containsString(
"Running `buck fix`. Invoke this manually with `buck fix --build-id ")));
}
@Provides @Named("videoTcpChannelOptions")
public Map<ChannelOption<?>, Object> provideVideoTcpChannelOptions(VideoDownloadServerConfig serverConfig) {
return ImmutableMap.of(
ChannelOption.SO_KEEPALIVE, serverConfig.isSoKeepAlive(),
ChannelOption.SO_SNDBUF, serverConfig.getSndBufferSize(),
ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, serverConfig.getWriteHighWater(),
ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, serverConfig.getWriteLowWater()
);
}
private void updateUnionFieldsAndRecordTypes(@Nonnull Descriptors.Descriptor union, boolean processExtensionOptions) {
final Map<String, RecordTypeBuilder> oldRecordTypes = ImmutableMap.copyOf(recordTypes);
recordTypes.clear();
unionFields.clear();
for (Descriptors.FieldDescriptor unionField : union.getFields()) {
Descriptors.Descriptor newDescriptor = unionField.getMessageType();
Descriptors.Descriptor oldDescriptor = findOldDescriptor(unionField, union);
if (unionFields.containsKey(newDescriptor)) {
if (!recordTypes.containsKey(newDescriptor.getName())) {
// Union field was seen before but the record type is unknown? This must not happen.
throw new MetaDataException("Unknown record type for union field " + unionField.getName());
}
// For existing record types, the preferred field is the last one, except if there is one whose name matches.
remapUnionField(newDescriptor, unionField);
} else if (oldDescriptor == null) {
// New field and record type.
RecordTypeBuilder recordType = processRecordType(unionField, processExtensionOptions);
if (recordType.getSinceVersion() != null && recordType.getSinceVersion() != version) {
throw new MetaDataException(String.format("Record type version (%d) does not match meta-data version (%d)",
recordType.getSinceVersion(), version));
} else {
recordType.setSinceVersion(version);
}
unionFields.put(newDescriptor, unionField);
} else {
updateRecordType(oldRecordTypes, oldDescriptor, newDescriptor);
unionFields.put(newDescriptor, unionField);
}
}
}
private JobConfig createJobConfigWithUrlAndName(String url, String name) {
return jobConfigBuilder()
.withName(name)
.withUrls(ImmutableMap.of(url,
UrlConfig.urlConfigBuilder().withWindowWidths(ImmutableList.of(600)).withMaxScrollHeight(100000).build()))
.build();
}
/**
* Constructs an instance of GrpcCarrierConstantServiceStub, using the given settings. This is
* protected so that it is easy to make a subclass, but otherwise, the static factory methods
* should be preferred.
*/
protected GrpcCarrierConstantServiceStub(
CarrierConstantServiceStubSettings settings,
ClientContext clientContext,
GrpcStubCallableFactory callableFactory)
throws IOException {
this.callableFactory = callableFactory;
GrpcCallSettings<GetCarrierConstantRequest, CarrierConstant>
getCarrierConstantTransportSettings =
GrpcCallSettings.<GetCarrierConstantRequest, CarrierConstant>newBuilder()
.setMethodDescriptor(getCarrierConstantMethodDescriptor)
.setParamsExtractor(
new RequestParamsExtractor<GetCarrierConstantRequest>() {
@Override
public Map<String, String> extract(GetCarrierConstantRequest request) {
ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
params.put("resource_name", String.valueOf(request.getResourceName()));
return params.build();
}
})
.build();
this.getCarrierConstantCallable =
callableFactory.createUnaryCallable(
getCarrierConstantTransportSettings,
settings.getCarrierConstantSettings(),
clientContext);
backgroundResources = new BackgroundResourceAggregation(clientContext.getBackgroundResources());
}
@Test
public void testFailedTransactionWorkflow()
{
try (IdleCheckExecutor executor = new IdleCheckExecutor()) {
CatalogManager catalogManager = new CatalogManager();
TransactionManager transactionManager = InMemoryTransactionManager.create(new TransactionManagerConfig(), executor.getExecutor(), catalogManager, finishingExecutor);
Connector c1 = new TpchConnectorFactory().create(CATALOG, ImmutableMap.of(), new TestingConnectorContext());
registerConnector(catalogManager, transactionManager, CATALOG, CATALOG_NAME, c1);
TransactionId transactionId = transactionManager.beginTransaction(false);
assertEquals(transactionManager.getAllTransactionInfos().size(), 1);
TransactionInfo transactionInfo = transactionManager.getTransactionInfo(transactionId);
assertFalse(transactionInfo.isAutoCommitContext());
assertTrue(transactionInfo.getCatalogNames().isEmpty());
assertFalse(transactionInfo.getWrittenConnectorId().isPresent());
ConnectorMetadata metadata = transactionManager.getOptionalCatalogMetadata(transactionId, CATALOG).get().getMetadata();
metadata.listSchemaNames(TEST_SESSION.toConnectorSession(CATALOG_NAME));
transactionInfo = transactionManager.getTransactionInfo(transactionId);
assertEquals(transactionInfo.getCatalogNames(), ImmutableList.of(CATALOG_NAME, INFORMATION_SCHEMA_ID, SYSTEM_TABLES_ID));
assertFalse(transactionInfo.getWrittenConnectorId().isPresent());
transactionManager.fail(transactionId);
assertEquals(transactionManager.getAllTransactionInfos().size(), 1);
assertPrestoExceptionThrownBy(() -> transactionManager.getCatalogMetadata(transactionId, CATALOG_NAME))
.hasErrorCode(TRANSACTION_ALREADY_ABORTED);
assertEquals(transactionManager.getAllTransactionInfos().size(), 1);
getFutureValue(transactionManager.asyncAbort(transactionId));
assertTrue(transactionManager.getAllTransactionInfos().isEmpty());
}
}