focal_method
stringlengths
13
60.9k
test_case
stringlengths
25
109k
@Override public Block toBlock(Type desiredType) { checkArgument(BIGINT.equals(desiredType), "type doesn't match: %s", desiredType); int numberOfRecords = numberOfRecords(); return new LongArrayBlock( numberOfRecords, Optional.ofNullable(nulls), longs == null ? new long[numberOfRecords] : longs); }
@Test public void testReadBlock() { PrestoThriftBlock columnsData = longColumn( new boolean[] {false, true, false, false, false, false, true}, new long[] {2, 0, 1, 3, 8, 4, 0}); Block actual = columnsData.toBlock(BIGINT); assertBlockEquals(actual, list(2L, null, 1L, 3L, 8L, 4L, null)); }
public static Collection<PerStepNamespaceMetrics> convert( String stepName, Map<MetricName, Long> counters, Map<MetricName, LockFreeHistogram.Snapshot> histograms, Map<MetricName, LabeledMetricNameUtils.ParsedMetricName> parsedPerWorkerMetricsCache) { Map<String, PerStepNamespaceMetrics> metricsByNamespace = new HashMap<>(); for (Entry<MetricName, Long> entry : counters.entrySet()) { MetricName metricName = entry.getKey(); Optional<MetricValue> metricValue = convertCounterToMetricValue(metricName, entry.getValue(), parsedPerWorkerMetricsCache); if (!metricValue.isPresent()) { continue; } PerStepNamespaceMetrics stepNamespaceMetrics = metricsByNamespace.get(metricName.getNamespace()); if (stepNamespaceMetrics == null) { stepNamespaceMetrics = new PerStepNamespaceMetrics() .setMetricValues(new ArrayList<>()) .setOriginalStep(stepName) .setMetricsNamespace(metricName.getNamespace()); metricsByNamespace.put(metricName.getNamespace(), stepNamespaceMetrics); } stepNamespaceMetrics.getMetricValues().add(metricValue.get()); } for (Entry<MetricName, LockFreeHistogram.Snapshot> entry : histograms.entrySet()) { MetricName metricName = entry.getKey(); Optional<MetricValue> metricValue = convertHistogramToMetricValue(metricName, entry.getValue(), parsedPerWorkerMetricsCache); if (!metricValue.isPresent()) { continue; } PerStepNamespaceMetrics stepNamespaceMetrics = metricsByNamespace.get(metricName.getNamespace()); if (stepNamespaceMetrics == null) { stepNamespaceMetrics = new PerStepNamespaceMetrics() .setMetricValues(new ArrayList<>()) .setOriginalStep(stepName) .setMetricsNamespace(metricName.getNamespace()); metricsByNamespace.put(metricName.getNamespace(), stepNamespaceMetrics); } stepNamespaceMetrics.getMetricValues().add(metricValue.get()); } return metricsByNamespace.values(); }
@Test public void testConvert_skipInvalidMetricNames() { Map<MetricName, LabeledMetricNameUtils.ParsedMetricName> parsedMetricNames = new HashMap<>(); Map<MetricName, Long> counters = new HashMap<>(); MetricName invalidName1 = MetricName.named("BigQuerySink", "**"); counters.put(invalidName1, 5L); Map<MetricName, LockFreeHistogram.Snapshot> histograms = new HashMap<>(); MetricName invalidName2 = MetricName.named("BigQuerySink", "****"); LockFreeHistogram nonEmptyLinearHistogram = new LockFreeHistogram(invalidName2, lienarBuckets); nonEmptyLinearHistogram.update(-5.0); histograms.put(invalidName2, nonEmptyLinearHistogram.getSnapshotAndReset().get()); Collection<PerStepNamespaceMetrics> conversionResult = MetricsToPerStepNamespaceMetricsConverter.convert( "testStep", counters, histograms, parsedMetricNames); assertThat(conversionResult.size(), equalTo(0)); assertThat(parsedMetricNames.size(), equalTo(0)); }
@Override public ObjectNode encode(KubevirtNode node, CodecContext context) { checkNotNull(node, "Kubevirt node cannot be null"); ObjectNode result = context.mapper().createObjectNode() .put(HOST_NAME, node.hostname()) .put(TYPE, node.type().name()) .put(STATE, node.state().name()) .put(MANAGEMENT_IP, node.managementIp().toString()); // serialize integration bridge config if (node.intgBridge() != null) { result.put(INTEGRATION_BRIDGE, node.intgBridge().toString()); } // serialize tunnel bridge config if (node.tunBridge() != null) { result.put(TUNNEL_BRIDGE, node.tunBridge().toString()); } // serialize data IP only if it presents if (node.dataIp() != null) { result.put(DATA_IP, node.dataIp().toString()); } // serialize physical interfaces, it is valid only if any of physical interface presents if (node.phyIntfs() != null && !node.phyIntfs().isEmpty()) { ArrayNode phyIntfs = context.mapper().createArrayNode(); node.phyIntfs().forEach(phyIntf -> { ObjectNode phyIntfJson = context.codec(KubevirtPhyInterface.class).encode(phyIntf, context); phyIntfs.add(phyIntfJson); }); result.set(PHYSICAL_INTERFACES, phyIntfs); } // serialize external bridge if exist if (node.gatewayBridgeName() != null) { result.put(GATEWAY_BRIDGE_NAME, node.gatewayBridgeName()); } return result; }
@Test public void testKubevirtComputeNodeEncode() { KubevirtPhyInterface phyIntf1 = DefaultKubevirtPhyInterface.builder() .network("mgmtnetwork") .intf("eth3") .physBridge(DEVICE_ID_1) .build(); KubevirtPhyInterface phyIntf2 = DefaultKubevirtPhyInterface.builder() .network("oamnetwork") .intf("eth4") .physBridge(DEVICE_ID_2) .build(); KubevirtNode node = DefaultKubevirtNode.builder() .hostname("worker") .type(KubevirtNode.Type.WORKER) .state(KubevirtNodeState.INIT) .managementIp(IpAddress.valueOf("10.10.10.1")) .intgBridge(DeviceId.deviceId("br-int")) .tunBridge(DeviceId.deviceId("br-tun")) .dataIp(IpAddress.valueOf("20.20.20.2")) .phyIntfs(ImmutableList.of(phyIntf1, phyIntf2)) .build(); ObjectNode nodeJson = kubevirtNodeCodec.encode(node, context); assertThat(nodeJson, matchesKubevirtNode(node)); }
public boolean isValid() { if (tokens == null) getTokens(); return valid; }
@Test public void testValidationProcess() { // TopicMultiInTheMiddle assertThat(new Topic("finance/#/closingprice")).isInValid(); // MultiNotAfterSeparator assertThat(new Topic("finance#")).isInValid(); // TopicMultiNotAlone assertThat(new Topic("/finance/#closingprice")).isInValid(); // SingleNotAferSeparator assertThat(new Topic("finance+")).isInValid(); assertThat(new Topic("finance/+")).isValid(); }
public String stringify(boolean value) { throw new UnsupportedOperationException( "stringify(boolean) was called on a non-boolean stringifier: " + toString()); }
@Test public void testDefaultStringifier() { PrimitiveStringifier stringifier = DEFAULT_STRINGIFIER; assertEquals("true", stringifier.stringify(true)); assertEquals("false", stringifier.stringify(false)); assertEquals("0.0", stringifier.stringify(0.0)); assertEquals("123456.7891234567", stringifier.stringify(123456.7891234567)); assertEquals("-98765.43219876543", stringifier.stringify(-98765.43219876543)); assertEquals("0.0", stringifier.stringify(0.0f)); assertEquals("987.6543", stringifier.stringify(987.6543f)); assertEquals("-123.4567", stringifier.stringify(-123.4567f)); assertEquals("0", stringifier.stringify(0)); assertEquals("1234567890", stringifier.stringify(1234567890)); assertEquals("-987654321", stringifier.stringify(-987654321)); assertEquals("0", stringifier.stringify(0l)); assertEquals("1234567890123456789", stringifier.stringify(1234567890123456789l)); assertEquals("-987654321987654321", stringifier.stringify(-987654321987654321l)); assertEquals("null", stringifier.stringify(null)); assertEquals("0x", stringifier.stringify(Binary.EMPTY)); assertEquals( "0x0123456789ABCDEF", stringifier.stringify(toBinary(0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF))); }
public static String buildErrorMessage(final Throwable throwable) { if (throwable == null) { return ""; } final List<String> messages = dedup(getErrorMessages(throwable)); final String msg = messages.remove(0); final String causeMsg = messages.stream() .filter(s -> !s.isEmpty()) .map(cause -> WordUtils.wrap(PREFIX + cause, 80, "\n\t", true)) .collect(Collectors.joining(System.lineSeparator())); return causeMsg.isEmpty() ? msg : msg + System.lineSeparator() + causeMsg; }
@Test public void shouldHandleRecursiveExceptions() { assertThat( buildErrorMessage(new RecursiveException("It went boom")), is("It went boom") ); }
public static Expression generateFilterExpression(SearchArgument sarg) { return translate(sarg.getExpression(), sarg.getLeaves()); }
@Test public void testLessThanEqualsOperand() { SearchArgument.Builder builder = SearchArgumentFactory.newBuilder(); SearchArgument arg = builder.startAnd().lessThanEquals("salary", PredicateLeaf.Type.LONG, 3000L).end().build(); UnboundPredicate expected = Expressions.lessThanOrEqual("salary", 3000L); UnboundPredicate actual = (UnboundPredicate) HiveIcebergFilterFactory.generateFilterExpression(arg); assertPredicatesMatch(expected, actual); }
@Override public List<Long> selectAllComputeNodes() { List<Long> nodeIds = availableID2ComputeNode.values().stream() .map(ComputeNode::getId) .collect(Collectors.toList()); nodeIds.forEach(this::selectWorkerUnchecked); return nodeIds; }
@Test public void testChooseAllComputedNodes() { { // empty compute nodes WorkerProvider workerProvider = new DefaultSharedDataWorkerProvider(ImmutableMap.of(), ImmutableMap.of()); Assert.assertTrue(workerProvider.selectAllComputeNodes().isEmpty()); } { // both compute nodes and backend are treated as compute nodes WorkerProvider workerProvider = new DefaultSharedDataWorkerProvider(ImmutableMap.copyOf(id2AllNodes), ImmutableMap.copyOf(id2AllNodes)); List<Long> computeNodeIds = workerProvider.selectAllComputeNodes(); Assert.assertEquals(id2AllNodes.size(), computeNodeIds.size()); Set<Long> computeNodeIdSet = new HashSet<>(computeNodeIds); for (ComputeNode computeNode : id2AllNodes.values()) { Assert.assertTrue(computeNodeIdSet.contains(computeNode.getId())); testUsingWorkerHelper(workerProvider, computeNode.getId()); } } }
public Map<String, Object> getContext(Map<String, Object> modelMap, Class<? extends SparkController> controller, String viewName) { Map<String, Object> context = new HashMap<>(modelMap); context.put("currentGoCDVersion", CurrentGoCDVersion.getInstance().getGocdDistVersion()); context.put("railsAssetsService", railsAssetsService); context.put("webpackAssetsService", webpackAssetsService); context.put("securityService", securityService); context.put("maintenanceModeService", maintenanceModeService); context.put("currentUser", SessionUtils.currentUsername()); context.put("controllerName", humanizedControllerName(controller)); context.put("viewName", viewName); context.put("currentVersion", CurrentGoCDVersion.getInstance()); context.put("toggles", Toggles.class); context.put("goUpdate", versionInfoService.getGoUpdate()); context.put("goUpdateCheckEnabled", versionInfoService.isGOUpdateCheckEnabled()); context.put("serverTimezoneUTCOffset", TimeZone.getDefault().getOffset(new Date().getTime())); context.put("spaRefreshInterval", SystemEnvironment.goSpaRefreshInterval()); context.put("spaTimeout", SystemEnvironment.goSpaTimeout()); context.put("showAnalyticsDashboard", showAnalyticsDashboard()); context.put("devMode", !new SystemEnvironment().useCompressedJs()); context.put("serverSiteUrls", GSON.toJson(serverConfigService.getServerSiteUrls())); return context; }
@Test void shouldNotShowAnalyticsDashboardPluginIsNotPresent() { Map<String, Object> modelMap = new HashMap<>(); when(securityService.isUserAdmin(any(Username.class))).thenReturn(true); when(pluginInfoFinder.allPluginInfos(PluginConstants.ANALYTICS_EXTENSION)).thenReturn(List.of(new CombinedPluginInfo())); Map<String, Object> contect = initialContextProvider.getContext(modelMap, dummySparkController.getClass(), "viewName"); assertThat(contect.get("showAnalyticsDashboard")).isEqualTo(false); }
protected static HttpUriRequest postRequest(String url, Map<String, String> params, boolean supportEnhancedContentType) { HttpPost httpPost = new HttpPost(url); if (params != null && params.size() > 0) { List<NameValuePair> list = new ArrayList<>(params.size()); for (Entry<String, String> entry : params.entrySet()) { list.add(new BasicNameValuePair(entry.getKey(), entry.getValue())); } httpPost.setEntity(new UrlEncodedFormEntity(list, Consts.UTF_8)); if (!supportEnhancedContentType) { httpPost.setHeader(HTTP_HEADER_CONTENT_TYPE, HTTP_HEADER_CONTENT_TYPE_URLENCODED); } } return httpPost; }
@Test public void postRequest() throws HttpException, IOException { // Processor is required because it will determine the final request body including // headers before outgoing. RequestContent processor = new RequestContent(); Map<String, String> params = new HashMap<String, String>(); params.put("a", "1"); params.put("b", "2+"); params.put("c", "3 "); HttpUriRequest request; request = SentinelApiClient.postRequest("/test", params, false); assertNotNull(request); processor.process(request, null); assertNotNull(request.getFirstHeader("Content-Type")); assertEquals("application/x-www-form-urlencoded", request.getFirstHeader("Content-Type").getValue()); request = SentinelApiClient.postRequest("/test", params, true); assertNotNull(request); processor.process(request, null); assertNotNull(request.getFirstHeader("Content-Type")); assertEquals("application/x-www-form-urlencoded; charset=UTF-8", request.getFirstHeader("Content-Type").getValue()); }
public static DataSource createDataSource(final File yamlFile) throws SQLException, IOException { YamlJDBCConfiguration rootConfig = YamlEngine.unmarshal(yamlFile, YamlJDBCConfiguration.class); return createDataSource(new YamlDataSourceConfigurationSwapper().swapToDataSources(rootConfig.getDataSources()), rootConfig); }
@Test void assertCreateDataSourceWithBytesForExternalDataSources() throws Exception { Map<String, DataSource> dataSourceMap = new HashMap<>(2, 1F); dataSourceMap.put("ds_0", new MockedDataSource()); dataSourceMap.put("ds_1", new MockedDataSource()); assertDataSource(YamlShardingSphereDataSourceFactory.createDataSource(dataSourceMap, readFile(getYamlFileUrl()).getBytes())); }
public FloatArrayAsIterable usingTolerance(double tolerance) { return new FloatArrayAsIterable(tolerance(tolerance), iterableSubject()); }
@Test public void usingTolerance_containsAtLeast_primitiveFloatArray_inOrder_success() { assertThat(array(1.1f, TOLERABLE_2POINT2, 3.3f)) .usingTolerance(DEFAULT_TOLERANCE) .containsAtLeast(array(1.1f, 2.2f)) .inOrder(); }
public static Socket fork(ZContext ctx, IAttachedRunnable runnable, Object... args) { Socket pipe = ctx.createSocket(SocketType.PAIR); assert (pipe != null); pipe.bind(String.format(Locale.ENGLISH, "inproc://zctx-pipe-%d", pipe.hashCode())); // Connect child pipe to our pipe ZContext ccontext = ctx.shadow(); Socket cpipe = ccontext.createSocket(SocketType.PAIR); assert (cpipe != null); cpipe.connect(String.format(Locale.ENGLISH, "inproc://zctx-pipe-%d", pipe.hashCode())); // Prepare child thread Thread shim = new ShimThread(ccontext, runnable, args, cpipe); shim.start(); return pipe; }
@Test @Ignore public void testClosePipe() { ZContext ctx = new ZContext(); Socket pipe = ZThread.fork(ctx, (args, ctx1, pipe1) -> { pipe1.recvStr(); pipe1.send("pong"); }); assertThat(pipe, notNullValue()); boolean rc = pipe.send("ping"); assertThat(rc, is(true)); String pong = pipe.recvStr(); assertThat(pong, is("pong")); try { rc = pipe.send("boom ?!"); assertThat("pipe was closed pretty fast", rc, is(true)); } catch (ZMQException e) { int errno = e.getErrorCode(); assertThat("Expected exception has the wrong code", ZError.ETERM, is(errno)); } ctx.close(); }
public boolean areAllowedAllNamespaces(String tenant, String fromTenant, String fromNamespace) { return true; }
@Test void areAllowedAllNamespaces() { assertTrue(flowService.areAllowedAllNamespaces("tenant", "fromTenant", "fromNamespace")); }
public void addServletListeners(EventListener... listeners) { for (EventListener listener : listeners) { handler.addEventListener(listener); } }
@Test void addsServletListeners() { final ServletContextListener listener = new DebugListener(); environment.addServletListeners(listener); assertThat(handler.getEventListeners()).contains(listener); }
@Override @Transactional(rollbackFor = Exception.class) // 添加事务,异常则回滚所有导入 public UserImportRespVO importUserList(List<UserImportExcelVO> importUsers, boolean isUpdateSupport) { // 1.1 参数校验 if (CollUtil.isEmpty(importUsers)) { throw exception(USER_IMPORT_LIST_IS_EMPTY); } // 1.2 初始化密码不能为空 String initPassword = configApi.getConfigValueByKey(USER_INIT_PASSWORD_KEY).getCheckedData(); if (StrUtil.isEmpty(initPassword)) { throw exception(USER_IMPORT_INIT_PASSWORD); } // 2. 遍历,逐个创建 or 更新 UserImportRespVO respVO = UserImportRespVO.builder().createUsernames(new ArrayList<>()) .updateUsernames(new ArrayList<>()).failureUsernames(new LinkedHashMap<>()).build(); importUsers.forEach(importUser -> { // 2.1.1 校验字段是否符合要求 try { ValidationUtils.validate(BeanUtils.toBean(importUser, UserSaveReqVO.class).setPassword(initPassword)); } catch (ConstraintViolationException ex){ respVO.getFailureUsernames().put(importUser.getUsername(), ex.getMessage()); return; } // 2.1.2 校验,判断是否有不符合的原因 try { validateUserForCreateOrUpdate(null, null, importUser.getMobile(), importUser.getEmail(), importUser.getDeptId(), null); } catch (ServiceException ex) { respVO.getFailureUsernames().put(importUser.getUsername(), ex.getMessage()); return; } // 2.2.1 判断如果不存在,在进行插入 AdminUserDO existUser = userMapper.selectByUsername(importUser.getUsername()); if (existUser == null) { userMapper.insert(BeanUtils.toBean(importUser, AdminUserDO.class) .setPassword(encodePassword(initPassword)).setPostIds(new HashSet<>())); // 设置默认密码及空岗位编号数组 respVO.getCreateUsernames().add(importUser.getUsername()); return; } // 2.2.2 如果存在,判断是否允许更新 if (!isUpdateSupport) { respVO.getFailureUsernames().put(importUser.getUsername(), USER_USERNAME_EXISTS.getMsg()); return; } AdminUserDO updateUser = BeanUtils.toBean(importUser, AdminUserDO.class); updateUser.setId(existUser.getId()); userMapper.updateById(updateUser); respVO.getUpdateUsernames().add(importUser.getUsername()); }); return respVO; }
@Test public void testImportUserList_03() { // mock 数据 AdminUserDO dbUser = randomAdminUserDO(); userMapper.insert(dbUser); // 准备参数 UserImportExcelVO importUser = randomPojo(UserImportExcelVO.class, o -> { o.setStatus(randomEle(CommonStatusEnum.values()).getStatus()); // 保证 status 的范围 o.setSex(randomEle(SexEnum.values()).getSex()); // 保证 sex 的范围 o.setUsername(dbUser.getUsername()); o.setEmail(randomEmail()); o.setMobile(randomMobile()); }); // mock deptService 的方法 DeptDO dept = randomPojo(DeptDO.class, o -> { o.setId(importUser.getDeptId()); o.setStatus(CommonStatusEnum.ENABLE.getStatus()); }); when(deptService.getDept(eq(dept.getId()))).thenReturn(dept); // 调用 UserImportRespVO respVO = userService.importUserList(newArrayList(importUser), false); // 断言 assertEquals(0, respVO.getCreateUsernames().size()); assertEquals(0, respVO.getUpdateUsernames().size()); assertEquals(1, respVO.getFailureUsernames().size()); assertEquals(USER_USERNAME_EXISTS.getMsg(), respVO.getFailureUsernames().get(importUser.getUsername())); }
public static Field p(String fieldName) { return SELECT_ALL_FROM_SOURCES_ALL.where(fieldName); }
@Test void fuzzy() { String q = Q.p("f1").fuzzy("text to match").build(); assertEquals("yql=select * from sources * where f1 contains (fuzzy(\"text to match\"))", q); }
public static String getGlobalContextEntry(String key) { return GLOBAL_CONTEXT_MAP.get(key); }
@Test public void testVerifyProcessID() throws Throwable { assertThat( getGlobalContextEntry(PARAM_PROCESS)) .describedAs("global context value of %s", PARAM_PROCESS) .isEqualTo(PROCESS_ID); }
public static BytesInput concat(BytesInput... inputs) { return new SequenceBytesIn(Arrays.asList(inputs)); }
@Test public void testConcat() throws IOException { byte[] data = new byte[1000]; RANDOM.nextBytes(data); Supplier<BytesInput> factory = () -> BytesInput.concat( BytesInput.from(toByteBuffer(data, 0, 250)), BytesInput.empty(), BytesInput.from(toByteBuffer(data, 250, 250)), BytesInput.from(data, 500, 250), BytesInput.from(new ByteArrayInputStream(data, 750, 250), 250)); validate(data, factory); }
public String getFiltersFile() { return filtersFile; }
@Test public void testExclusionsOption() { final DistCpOptions.Builder builder = new DistCpOptions.Builder( new Path("hdfs://localhost:8020/source/first"), new Path("hdfs://localhost:8020/target/")); Assert.assertNull(builder.build().getFiltersFile()); builder.withFiltersFile("/tmp/filters.txt"); Assert.assertEquals("/tmp/filters.txt", builder.build().getFiltersFile()); }
@Cacheable(value = "metadata-response", key = "#samlMetadataRequest.cacheableKey()") public SamlMetadataResponse resolveSamlMetadata(SamlMetadataRequest samlMetadataRequest) { LOGGER.info("Cache not found for saml-metadata {}", samlMetadataRequest.hashCode()); Connection connection = connectionService.getConnectionByEntityId(samlMetadataRequest.getConnectionEntityId()); MetadataResponseStatus metadataResponseStatus = null; nl.logius.digid.dc.domain.service.Service service = null; if (connection == null) { metadataResponseStatus = CONNECTION_NOT_FOUND; } else if (!connection.getStatus().isAllowed()) { metadataResponseStatus = CONNECTION_INACTIVE; } else if (!connection.getOrganization().getStatus().isAllowed()) { metadataResponseStatus = ORGANIZATION_INACTIVE; } else if (Boolean.FALSE.equals(connection.getOrganizationRole().getStatus().isAllowed())) { metadataResponseStatus = ORGANIZATION_ROLE_INACTIVE; } else { String serviceUUID = samlMetadataRequest.getServiceUuid() == null ? getServiceUUID(connection, samlMetadataRequest.getServiceEntityId(), samlMetadataRequest.getServiceIdx()) : samlMetadataRequest.getServiceUuid(); samlMetadataRequest.setServiceUuid(serviceUUID); service = serviceService.serviceExists(connection, samlMetadataRequest.getServiceEntityId(), serviceUUID); if (service == null) { metadataResponseStatus = SERVICE_NOT_FOUND; } else if (!service.getStatus().isAllowed()) { metadataResponseStatus = SERVICE_INACTIVE; } } if (metadataResponseStatus != null) { return metadataResponseMapper.mapErrorResponse(metadataResponseStatus.name(), metadataResponseStatus.label); } else { String samlMetadata = generateReducedMetadataString(connection, service.getEntityId()); return metadataResponseMapper.mapSuccessResponse(samlMetadata, connection, service, STATUS_OK.name()); } }
@Test void serviceNotFoundTest() { Connection connection = newConnection(SAML_COMBICONNECT, true, true, true); when(connectionServiceMock.getConnectionByEntityId(anyString())).thenReturn(connection); when(serviceServiceMock.serviceExists(any(Connection.class), anyString(), anyString())).thenReturn(null); SamlMetadataResponse response = metadataRetrieverServiceMock.resolveSamlMetadata(newMetadataRequest()); assertEquals(SERVICE_NOT_FOUND.name(), response.getRequestStatus()); assertEquals(SERVICE_NOT_FOUND.label, response.getErrorDescription()); }
public String createULID(Message message) { checkTimestamp(message.getTimestamp().getMillis()); try { return createULID(message.getTimestamp().getMillis(), message.getSequenceNr()); } catch (Exception e) { LOG.error("Exception while creating ULID.", e); return ulid.nextULID(message.getTimestamp().getMillis()); } }
@Test public void intMaxGenerate() { final MessageULIDGenerator generator = new MessageULIDGenerator(new ULID()); final long ts = Tools.nowUTC().getMillis(); ULID.Value parsedULID = ULID.parseULID(generator.createULID(ts, Integer.MAX_VALUE)); assertThat(extractSequenceNr(parsedULID)).isEqualTo(Integer.MAX_VALUE); }
@Override public boolean exists() { setupClientIfNeeded(); try (Reader<String> historyReader = createHistoryReader()) { return historyReader.hasMessageAvailable(); } catch (IOException e) { log.error("Encountered issues on checking existence of database history", e); throw new RuntimeException("Encountered issues on checking existence of database history", e); } }
@Test public void testExists() throws Exception { // happy path testHistoryTopicContent(true, false); assertTrue(history.exists()); // Set history to use dummy topic Configuration config = Configuration.create() .with(PulsarDatabaseHistory.SERVICE_URL, brokerUrl.toString()) .with(PulsarDatabaseHistory.TOPIC, "persistent://my-property/my-ns/dummytopic") .with(DatabaseHistory.NAME, "my-db-history") .with(DatabaseHistory.SKIP_UNPARSEABLE_DDL_STATEMENTS, true) .build(); history.configure(config, null, DatabaseHistoryListener.NOOP, true); history.start(); // dummytopic should not exist yet assertFalse(history.exists()); }
@Udf public String rpad( @UdfParameter(description = "String to be padded") final String input, @UdfParameter(description = "Target length") final Integer targetLen, @UdfParameter(description = "Padding string") final String padding) { if (input == null) { return null; } if (padding == null || padding.isEmpty() || targetLen == null || targetLen < 0) { return null; } final StringBuilder sb = new StringBuilder(targetLen + padding.length()); sb.append(input); final int padChars = Math.max(targetLen - input.length(), 0); for (int i = 0; i < padChars; i += padding.length()) { sb.append(padding); } sb.setLength(targetLen); return sb.toString(); }
@Test public void shouldReturnEmptyStringForZeroLength() { final String result = udf.rpad("foo", 0, "bar"); assertThat(result, is("")); }
public int runInteractively() { displayWelcomeMessage(); RemoteServerSpecificCommand.validateClient(terminal.writer(), restClient); boolean eof = false; while (!eof) { try { handleLine(nextNonCliCommand()); } catch (final EndOfFileException exception) { // EOF is fine, just terminate the REPL terminal.writer().println("Exiting ksqlDB."); eof = true; } catch (final Exception exception) { LOGGER.error("An error occurred while running a command. Error = " + exception.getMessage(), exception); terminal.printError(ErrorMessageUtil.buildErrorMessage(exception), exception.toString()); } terminal.flush(); } return NO_ERROR; }
@Test public void shouldPrintWarningOnUnknownServerVersion() throws Exception { givenRunInteractivelyWillExit(); final KsqlRestClient mockRestClient = givenMockRestClient("bad-version"); new Cli(1L, 1L, mockRestClient, console) .runInteractively(); assertThat( terminal.getOutputString(), containsString("WARNING: Could not identify server version.") ); }
@Override public void process(HttpResponse response, HttpContext context) throws HttpException, IOException { List<Header> warnings = Arrays.stream(response.getHeaders("Warning")).filter(header -> !this.isDeprecationMessage(header.getValue())).collect(Collectors.toList()); response.removeHeaders("Warning"); warnings.stream().forEach(header -> response.addHeader(header)); }
@Test public void testInterceptorMultipleHeaderFilteredWarning() throws IOException, HttpException { OpenSearchFilterDeprecationWarningsInterceptor interceptor = new OpenSearchFilterDeprecationWarningsInterceptor(); HttpResponse response = new BasicHttpResponse(new BasicStatusLine(new ProtocolVersion("HTTP", 0, 0), 0, null)); response.addHeader("Test", "This header should not trigger the interceptor."); response.addHeader("Warning", "This warning should not trigger the interceptor."); response.addHeader("Warning", "This text contains the trigger: setting was deprecated in OpenSearch - and should be filtered out"); assertThat(response.getAllHeaders()) .as("Number of Headers should be 3 before start.") .hasSize(3); interceptor.process(response, null); assertThat(response.getAllHeaders()) .as("Number of Headers should be 1 less after running the interceptor.") .hasSize(2); }
@ScalarOperator(LESS_THAN) @SqlType(StandardTypes.BOOLEAN) public static boolean lessThan(@SqlType(StandardTypes.INTEGER) long left, @SqlType(StandardTypes.INTEGER) long right) { return left < right; }
@Test public void testLessThan() { assertFunction("INTEGER'37' < INTEGER'37'", BOOLEAN, false); assertFunction("INTEGER'37' < INTEGER'17'", BOOLEAN, false); assertFunction("INTEGER'17' < INTEGER'37'", BOOLEAN, true); assertFunction("INTEGER'17' < INTEGER'17'", BOOLEAN, false); }
public static ConfigurableResource parseResourceConfigValue(String value) throws AllocationConfigurationException { return parseResourceConfigValue(value, Long.MAX_VALUE); }
@Test public void testParseNewStyleResourceMemoryNegative() throws Exception { expectNegativeValueOfResource("memory"); parseResourceConfigValue("memory-mb=-5120,vcores=2"); }
@Override void toHtml() throws IOException { writeHtmlHeader(); htmlCoreReport.toHtml(); writeHtmlFooter(); }
@Test public void testEmptyCounter() throws IOException { final HtmlReport htmlReport = new HtmlReport(collector, null, javaInformationsList, Period.TOUT, writer); // rapport avec counter sans requête counter.clear(); errorCounter.clear(); htmlReport.toHtml(null, null); assertNotEmptyAndClear(writer); }
@Override public void close() { if (_executionFuture != null) { _executionFuture.cancel(true); } }
@Test public void shouldNotErrorOutWhenIncorrectDataSchemaProvidedWithEmptyRowsSelection() { // Given: QueryContext queryContext = QueryContextConverterUtils.getQueryContext("SELECT strCol, intCol FROM tbl"); DataSchema resultSchema = new DataSchema(new String[]{"strCol", "intCol"}, new DataSchema.ColumnDataType[]{DataSchema.ColumnDataType.STRING, DataSchema.ColumnDataType.STRING}); DataSchema desiredSchema = new DataSchema(new String[]{"strCol", "intCol"}, new DataSchema.ColumnDataType[]{DataSchema.ColumnDataType.STRING, DataSchema.ColumnDataType.INT}); List<BaseResultsBlock> dataBlocks = Collections.emptyList(); InstanceResponseBlock emptySelectionResponseBlock = new InstanceResponseBlock(new SelectionResultsBlock(resultSchema, Collections.emptyList(), queryContext)); QueryExecutor queryExecutor = mockQueryExecutor(dataBlocks, emptySelectionResponseBlock); LeafStageTransferableBlockOperator operator = new LeafStageTransferableBlockOperator(OperatorTestUtil.getTracingContext(), mockQueryRequests(1), desiredSchema, queryExecutor, _executorService); _operatorRef.set(operator); // When: TransferableBlock resultBlock = operator.nextBlock(); // Then: Assert.assertTrue(resultBlock.isEndOfStreamBlock()); operator.close(); }
public static String getHeartbeatClientIp() { String ip = SentinelConfig.getConfig(HEARTBEAT_CLIENT_IP, true); if (StringUtil.isBlank(ip)) { ip = HostNameUtil.getIp(); } return ip; }
@Test public void testGetHeartbeatClientIp() { String clientIp = "10.10.10.10"; SentinelConfig.setConfig(TransportConfig.HEARTBEAT_CLIENT_IP, clientIp); // Set heartbeat client ip to system property. String ip = TransportConfig.getHeartbeatClientIp(); assertNotNull(ip); assertEquals(clientIp, ip); // Set no heartbeat client ip. SentinelConfig.setConfig(TransportConfig.HEARTBEAT_CLIENT_IP, ""); assertTrue(StringUtil.isNotEmpty(TransportConfig.getHeartbeatClientIp())); }
public void addResources(ConcurrentMap<String, ? extends LocallyCachedBlob> blobs) { for (LocallyCachedBlob b : blobs.values()) { currentSize += b.getSizeOnDisk(); if (b.isUsed()) { LOG.debug("NOT going to clean up {}, {} depends on it", b.getKey(), b.getDependencies()); // always retain resources in use continue; } LOG.debug("Possibly going to clean up {} ts {} size {}", b.getKey(), b.getLastUsed(), b.getSizeOnDisk()); noReferences.put(b, blobs); } }
@Test public void testAddResources() { PortAndAssignment pna1 = new PortAndAssignmentImpl(1, new LocalAssignment("topo1", Collections.emptyList())); PortAndAssignment pna2 = new PortAndAssignmentImpl(1, new LocalAssignment("topo2", Collections.emptyList())); String user = "user"; Map<String, Object> conf = new HashMap<>(); IAdvancedFSOps ops = mock(IAdvancedFSOps.class); LocalizedResourceRetentionSet lrretset = new LocalizedResourceRetentionSet(10); ConcurrentMap<String, LocalizedResource> lrset = new ConcurrentHashMap<>(); StormMetricsRegistry metricsRegistry = new StormMetricsRegistry(); LocalizedResource localresource1 = new LocalizedResource("key1", Paths.get("testfile1"), false, ops, conf, user, metricsRegistry); localresource1.addReference(pna1, null); LocalizedResource localresource2 = new LocalizedResource("key2", Paths.get("testfile2"), false, ops, conf, user, metricsRegistry); localresource2.addReference(pna1, null); // check adding reference to local resource with topology of same name localresource2.addReference(pna2, null); lrset.put("key1", localresource1); lrset.put("key2", localresource2); lrretset.addResources(lrset); assertEquals(0, lrretset.getSizeWithNoReferences(), "number to clean is not 0 " + lrretset.noReferences); assertTrue(localresource1.removeReference(pna1)); lrretset = new LocalizedResourceRetentionSet(10); lrretset.addResources(lrset); assertEquals(1, lrretset.getSizeWithNoReferences(), "number to clean is not 1 " + lrretset.noReferences); assertTrue(localresource2.removeReference(pna1)); lrretset = new LocalizedResourceRetentionSet(10); lrretset.addResources(lrset); assertEquals(1, lrretset.getSizeWithNoReferences(), "number to clean is not 1 " + lrretset.noReferences); assertTrue(localresource2.removeReference(pna2)); lrretset = new LocalizedResourceRetentionSet(10); lrretset.addResources(lrset); assertEquals(2, lrretset.getSizeWithNoReferences(), "number to clean is not 2 " + lrretset.noReferences); }
public OrderedProperties addStringPairs(String keyValuePairs) { PropertiesReader reader = new PropertiesReader(pairs); reader.read(keyValuePairs); return this; }
@Test public void addStringPairs() { OrderedProperties pairs = new OrderedProperties() .addStringPairs("first=1\nsecond=2\nthird=3\nFOURTH=4"); assertValueOrder(pairs, "1", "2", "3", "4"); }
@Override public WindowStoreIterator<V> backwardFetch(final K key, final Instant timeFrom, final Instant timeTo) throws IllegalArgumentException { Objects.requireNonNull(key, "key can't be null"); final List<ReadOnlyWindowStore<K, V>> stores = provider.stores(storeName, windowStoreType); for (final ReadOnlyWindowStore<K, V> windowStore : stores) { try { final WindowStoreIterator<V> result = windowStore.backwardFetch(key, timeFrom, timeTo); if (!result.hasNext()) { result.close(); } else { return result; } } catch (final InvalidStateStoreException e) { throw new InvalidStateStoreException( "State store is not available anymore and may have been migrated to another instance; " + "please re-discover its location from the state metadata."); } } return KeyValueIterators.emptyWindowStoreIterator(); }
@Test public void shouldThrowInvalidStateStoreExceptionOnRebalanceWhenBackwards() { final StateStoreProvider storeProvider = mock(StateStoreProvider.class); when(storeProvider.stores(anyString(), any())) .thenThrow(new InvalidStateStoreException("store is unavailable")); final CompositeReadOnlyWindowStore<Object, Object> store = new CompositeReadOnlyWindowStore<>( storeProvider, QueryableStoreTypes.windowStore(), "foo" ); assertThrows(InvalidStateStoreException.class, () -> store.backwardFetch("key", ofEpochMilli(1), ofEpochMilli(10))); }
public static Validator parses(final Function<String, ?> parser) { return (name, val) -> { if (val != null && !(val instanceof String)) { throw new IllegalArgumentException("validator should only be used with STRING defs"); } try { parser.apply((String)val); } catch (final Exception e) { throw new ConfigException("Configuration " + name + " is invalid: " + e.getMessage()); } }; }
@Test public void shouldPassNullsToParser() { // Given: final Validator validator = ConfigValidators.parses(parser); // When: validator.ensureValid("propName", null); // Then: verify(parser).apply(null); }
@Override public MetricType getType() { return MetricType.GAUGE_UNKNOWN; }
@Test public void getValue() { UnknownGauge gauge = new UnknownGauge("bar", URI.create("baz")); assertThat(gauge.getValue()).isEqualTo(URI.create("baz")); assertThat(gauge.getType()).isEqualTo(MetricType.GAUGE_UNKNOWN); //Null initialize gauge = new UnknownGauge("bar"); assertThat(gauge.getValue()).isNull(); assertThat(gauge.getType()).isEqualTo(MetricType.GAUGE_UNKNOWN); }
@NonNull public RouterFunction<ServerResponse> create() { var getHandler = new ExtensionGetHandler(scheme, client); var listHandler = new ExtensionListHandler(scheme, client); var createHandler = new ExtensionCreateHandler(scheme, client); var updateHandler = new ExtensionUpdateHandler(scheme, client); var deleteHandler = new ExtensionDeleteHandler(scheme, client); var patchHandler = new ExtensionPatchHandler(scheme, client); // TODO More handlers here var gvk = scheme.groupVersionKind(); var kind = gvk.kind(); var tagName = gvk.kind() + StringUtils.capitalize(gvk.version()); return SpringdocRouteBuilder.route() .GET(getHandler.pathPattern(), getHandler, builder -> builder.operationId("get" + kind) .description("Get " + kind) .tag(tagName) .parameter(parameterBuilder().in(ParameterIn.PATH) .name("name") .description("Name of " + scheme.singular())) .response(responseBuilder().responseCode("200") .description("Response single " + scheme.singular()) .implementation(scheme.type()))) .GET(listHandler.pathPattern(), listHandler, builder -> { builder.operationId("list" + kind) .description("List " + kind) .tag(tagName) .response(responseBuilder().responseCode("200") .description("Response " + scheme.plural()) .implementation(ListResult.generateGenericClass(scheme))); SortableRequest.buildParameters(builder); }) .POST(createHandler.pathPattern(), createHandler, builder -> builder.operationId("create" + kind) .description("Create " + kind) .tag(tagName) .requestBody(requestBodyBuilder() .description("Fresh " + scheme.singular()) .implementation(scheme.type())) .response(responseBuilder().responseCode("200") .description("Response " + scheme.plural() + " created just now") .implementation(scheme.type()))) .PUT(updateHandler.pathPattern(), updateHandler, builder -> builder.operationId("update" + kind) .description("Update " + kind) .tag(tagName) .parameter(parameterBuilder().in(ParameterIn.PATH) .name("name") .description("Name of " + scheme.singular())) .requestBody(requestBodyBuilder() .description("Updated " + scheme.singular()) .implementation(scheme.type())) .response(responseBuilder().responseCode("200") .description("Response " + scheme.plural() + " updated just now") .implementation(scheme.type()))) .PATCH(patchHandler.pathPattern(), patchHandler, builder -> builder.operationId("patch" + kind) .description("Patch " + kind) .tag(tagName) .parameter(parameterBuilder().in(ParameterIn.PATH) .name("name") .description("Name of " + scheme.singular())) .requestBody(requestBodyBuilder() .content(contentBuilder() .mediaType("application/json-patch+json") .schema( schemaBuilder().ref(RefUtils.constructRef(JsonPatch.SCHEMA_NAME)) ) ) ) .response(responseBuilder().responseCode("200") .description("Response " + scheme.singular() + " patched just now") .implementation(scheme.type()) ) ) .DELETE(deleteHandler.pathPattern(), deleteHandler, builder -> builder.operationId("delete" + kind) .description("Delete " + kind) .tag(tagName) .parameter(parameterBuilder().in(ParameterIn.PATH) .name("name") .description("Name of " + scheme.singular())) .response(responseBuilder().responseCode("200") .description("Response " + scheme.singular() + " deleted just now"))) .build(); }
@Test void shouldCreateSuccessfully() { var routerFunction = factory.create(); testCases().forEach(testCase -> { List<HttpMessageReader<?>> messageReaders = HandlerStrategies.withDefaults().messageReaders(); var request = ServerRequest.create(testCase.webExchange, messageReaders); var handlerFunc = routerFunction.route(request).block(); assertInstanceOf(testCase.expectHandlerType, handlerFunc); }); }
public static NamespaceName get(String tenant, String namespace) { validateNamespaceName(tenant, namespace); return get(tenant + '/' + namespace); }
@Test(expectedExceptions = IllegalArgumentException.class) public void namespace_emptyTenantElement() { NamespaceName.get("/cluster/namespace"); }
@Override public RemoteData.Builder serialize() { final RemoteData.Builder remoteBuilder = RemoteData.newBuilder(); remoteBuilder.addDataObjectStrings(total.toStorageData()); remoteBuilder.addDataLongs(getTimeBucket()); remoteBuilder.addDataStrings(getEntityId()); remoteBuilder.addDataStrings(getServiceId()); return remoteBuilder; }
@Test public void testSerialize() { function.accept(MeterEntity.newService("sum_sync_time", Layer.GENERAL), table1); SumPerMinLabeledFunction function2 = Mockito.spy(SumPerMinLabeledFunction.class); function2.deserialize(function.serialize().build()); assertThat(function2.getEntityId()).isEqualTo(function.getEntityId()); assertThat(function2.getTimeBucket()).isEqualTo(function.getTimeBucket()); }
public Main() { addOption(new Option("h", "help", "Displays the help screen") { protected void doProcess(String arg, LinkedList<String> remainingArgs) { showOptions(); // no need to process further if user just wants help System.exit(0); } }); addOption(new ParameterOption("c", "command", "Command can be encrypt or decrypt", "command") { protected void doProcess(String arg, String parameter, LinkedList<String> remainingArgs) { if ("encrypt".equals(parameter) || "decrypt".equals(parameter)) { command = parameter; } else { throw new IllegalArgumentException("Unknown command, was: " + parameter); } } }); addOption(new ParameterOption("p", "password", "Password to use", "password") { protected void doProcess(String arg, String parameter, LinkedList<String> remainingArgs) { password = parameter; } }); addOption(new ParameterOption("i", "input", "Text to encrypt or decrypt", "input") { protected void doProcess(String arg, String parameter, LinkedList<String> remainingArgs) { input = parameter; } }); addOption(new ParameterOption("a", "algorithm", "Optional algorithm to use", "algorithm") { protected void doProcess(String arg, String parameter, LinkedList<String> remainingArgs) { algorithm = parameter; } }); addOption(new ParameterOption("rsga", "salt", "Optional random salt generator algorithm to use", "salt") { protected void doProcess(String arg, String parameter, LinkedList<String> remainingArgs) { randomSaltGeneratorAlgorithm = parameter; } }); addOption(new ParameterOption("riga", "iv", "Optional random iv generator algorithm to use", "iv") { protected void doProcess(String arg, String parameter, LinkedList<String> remainingArgs) { randomIvGeneratorAlgorithm = parameter; } }); }
@Test public void testMainShowOptions() { assertDoesNotThrow(() -> Main.main(new String[] {})); }
public static <E> boolean addWithoutChecking(CheckedList<E> list, E element) { return list.addWithAssertChecking(element); }
@Test(expectedExceptions = AssertionError.class) public void testAddCycleWithAssertChecking() { final DataList list = new DataList(); CheckedUtil.addWithoutChecking(list, list); }
@Override public int permitMinimum() { return minConnections; }
@Test void permitMinimum() { builder.minConnections(2); Http2AllocationStrategy strategy = builder.build(); assertThat(strategy.maxConcurrentStreams()).isEqualTo(DEFAULT_MAX_CONCURRENT_STREAMS); assertThat(strategy.permitMaximum()).isEqualTo(DEFAULT_MAX_CONNECTIONS); assertThat(strategy.permitMinimum()).isEqualTo(2); }
public static List<String> getJavaOpts(Configuration conf) { String adminOpts = conf.get(YarnConfiguration.NM_CONTAINER_LOCALIZER_ADMIN_JAVA_OPTS_KEY, YarnConfiguration.NM_CONTAINER_LOCALIZER_ADMIN_JAVA_OPTS_DEFAULT); String userOpts = conf.get(YarnConfiguration.NM_CONTAINER_LOCALIZER_JAVA_OPTS_KEY, YarnConfiguration.NM_CONTAINER_LOCALIZER_JAVA_OPTS_DEFAULT); boolean isExtraJDK17OptionsConfigured = conf.getBoolean(YarnConfiguration.NM_CONTAINER_LOCALIZER_JAVA_OPTS_ADD_EXPORTS_KEY, YarnConfiguration.NM_CONTAINER_LOCALIZER_JAVA_OPTS_ADD_EXPORTS_DEFAULT); if (Shell.isJavaVersionAtLeast(17) && isExtraJDK17OptionsConfigured) { userOpts = userOpts.trim().concat(" " + ADDITIONAL_JDK17_PLUS_OPTIONS); } List<String> adminOptionList = Arrays.asList(adminOpts.split("\\s+")); List<String> userOptionList = Arrays.asList(userOpts.split("\\s+")); return Stream.concat(adminOptionList.stream(), userOptionList.stream()) .filter(s -> !s.isEmpty()) .collect(Collectors.toList()); }
@Test public void testDefaultJavaOptionsWhenExtraJDK17OptionsAreConfigured() throws Exception { ContainerLocalizerWrapper wrapper = new ContainerLocalizerWrapper(); ContainerLocalizer localizer = wrapper.setupContainerLocalizerForTest(); Configuration conf = new Configuration(); conf.setBoolean(YarnConfiguration.NM_CONTAINER_LOCALIZER_JAVA_OPTS_ADD_EXPORTS_KEY, true); List<String> javaOpts = localizer.getJavaOpts(conf); if (Shell.isJavaVersionAtLeast(17)) { Assert.assertTrue(javaOpts.contains("--add-exports=java.base/sun.net.dns=ALL-UNNAMED")); Assert.assertTrue(javaOpts.contains("--add-exports=java.base/sun.net.util=ALL-UNNAMED")); } Assert.assertTrue(javaOpts.contains("-Xmx256m")); }
public String defaultRemoteUrl() { final String sanitizedUrl = sanitizeUrl(); try { URI uri = new URI(sanitizedUrl); if (uri.getUserInfo() != null) { uri = new URI(uri.getScheme(), removePassword(uri.getUserInfo()), uri.getHost(), uri.getPort(), uri.getPath(), uri.getQuery(), uri.getFragment()); return uri.toString(); } } catch (URISyntaxException e) { return sanitizedUrl; } return sanitizedUrl; }
@Test void shouldNotModifyFileURIS() { assertThat(new HgUrlArgument("file://junk").defaultRemoteUrl(), is("file://junk")); }
public static NodeList selectNodeList(Document document, String xPathExpression) throws TransformerException { XObject xObject = XPathAPI.eval(document, xPathExpression, getPrefixResolver(document)); return xObject.nodelist(); }
@Test public void testSelectNodeList() throws ParserConfigurationException, SAXException, IOException, TidyException, TransformerException { String responseData = "<book><page>one</page><page>two</page><empty></empty><a><b></b></a></book>"; Document testDoc = XPathUtil.makeDocument( new ByteArrayInputStream(responseData.getBytes(StandardCharsets.UTF_8)), false, false, false, false, false, false, false, false, false); String xpathquery = "/book/page"; NodeList nodeList = XPathUtil.selectNodeList(testDoc, xpathquery); assertEquals(2, nodeList.getLength()); Element e0 = (Element) nodeList.item(0); Element e1 = (Element) nodeList.item(1); assertEquals("one", e0.getTextContent()); assertEquals("two", e1.getTextContent()); }
static Schema removeFields(Schema schema, String... fields) { List<String> exclude = Arrays.stream(fields).collect(Collectors.toList()); Schema.Builder builder = Schema.builder(); for (Field field : schema.getFields()) { if (exclude.contains(field.getName())) { continue; } builder.addField(field); } return builder.build(); }
@Test public void testPubsubRowToMessageParDo_attributesWithoutTimestamp() { Map<String, String> attributes = new HashMap<>(); attributes.put("a", "1"); attributes.put("b", "2"); attributes.put("c", "3"); Row withAttributes = Row.withSchema(NON_USER_WITH_BYTES_PAYLOAD) .addValues(attributes, Instant.now(), new byte[] {}) .build(); assertEquals( attributes, doFn(NON_USER_WITH_BYTES_PAYLOAD, null).attributesWithoutTimestamp(withAttributes)); Schema withoutAttributesSchema = removeFields(NON_USER_WITH_BYTES_PAYLOAD, DEFAULT_ATTRIBUTES_KEY_NAME); Row withoutAttributes = Row.withSchema(withoutAttributesSchema).addValues(Instant.now(), new byte[] {}).build(); assertEquals( ImmutableMap.of(), doFn(withoutAttributesSchema, null).attributesWithoutTimestamp(withoutAttributes)); }
public Record convert(final AbstractWALEvent event) { if (filter(event)) { return createPlaceholderRecord(event); } if (!(event instanceof AbstractRowEvent)) { return createPlaceholderRecord(event); } PipelineTableMetaData tableMetaData = getPipelineTableMetaData(((AbstractRowEvent) event).getTableName()); if (event instanceof WriteRowEvent) { return handleWriteRowEvent((WriteRowEvent) event, tableMetaData); } if (event instanceof UpdateRowEvent) { return handleUpdateRowEvent((UpdateRowEvent) event, tableMetaData); } if (event instanceof DeleteRowEvent) { return handleDeleteRowEvent((DeleteRowEvent) event, tableMetaData); } throw new UnsupportedSQLOperationException(""); }
@Test void assertConvertFailure() { AbstractRowEvent event = new AbstractRowEvent() { }; event.setSchemaName(""); event.setTableName("t_order"); assertThrows(UnsupportedSQLOperationException.class, () -> walEventConverter.convert(event)); }
@Override public ShenyuContext build(final ServerWebExchange exchange) { Pair<String, MetaData> buildData = buildData(exchange); return decoratorMap.get(buildData.getLeft()).decorator(buildDefaultContext(exchange.getRequest()), buildData.getRight()); }
@Test public void testBuild() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("http://localhost:8080/http") .remoteAddress(new InetSocketAddress(8092)) .header("MetaDataCache", "Hello") .build()); ShenyuContext shenyuContext = defaultShenyuContextBuilder.build(exchange); assertNotNull(shenyuContext); assertEquals(RpcTypeEnum.HTTP.getName(), shenyuContext.getRpcType()); }
public static ConnAckBuilder connAck() { return new ConnAckBuilder(); }
@Test public void testConnAckWithProperties() { final MqttConnAckMessage ackMsg = MqttMessageBuilders.connAck() .properties(new PropertiesInitializer<MqttMessageBuilders.ConnAckPropertiesBuilder>() { @Override public void apply(MqttMessageBuilders.ConnAckPropertiesBuilder builder) { builder.assignedClientId("client1234"); builder.userProperty("custom_property", "value"); } }).build(); final String clientId = (String) ackMsg.variableHeader() .properties() .getProperty(MqttProperties.MqttPropertyType.ASSIGNED_CLIENT_IDENTIFIER.value()) .value(); assertEquals("client1234", clientId); }
public static String toJsonStr(JSON json, int indentFactor) { if (null == json) { return null; } return json.toJSONString(indentFactor); }
@Test public void toJsonStrTest() { final UserA a1 = new UserA(); a1.setA("aaaa"); a1.setDate(DateUtil.date()); a1.setName("AAAAName"); final UserA a2 = new UserA(); a2.setA("aaaa222"); a2.setDate(DateUtil.date()); a2.setName("AAAA222Name"); final ArrayList<UserA> list = CollectionUtil.newArrayList(a1, a2); final HashMap<String, Object> map = MapUtil.newHashMap(); map.put("total", 13); map.put("rows", list); final String str = JSONUtil.toJsonPrettyStr(map); JSONUtil.parse(str); assertNotNull(str); }
@VisibleForTesting Path getActualPath() throws IOException { Path path = localPath; FileStatus status = localFs.getFileStatus(path); if (status != null && status.isDirectory()) { // for certain types of resources that get unpacked, the original file may // be found under the directory with the same name (see // FSDownload.unpack); check if the path is a directory and if so look // under it path = new Path(path, path.getName()); } return path; }
@Test public void testGetActualPath() throws Exception { Configuration conf = new Configuration(); conf.setBoolean(YarnConfiguration.SHARED_CACHE_ENABLED, true); LocalResource resource = mock(LocalResource.class); // give public visibility when(resource.getVisibility()).thenReturn(LocalResourceVisibility.PUBLIC); Path localPath = new Path("foo.jar"); String user = "joe"; SCMUploaderProtocol scmClient = mock(SCMUploaderProtocol.class); FileSystem fs = mock(FileSystem.class); FileSystem localFs = mock(FileSystem.class); // stub it to return a status that indicates a directory FileStatus status = mock(FileStatus.class); when(status.isDirectory()).thenReturn(true); when(localFs.getFileStatus(localPath)).thenReturn(status); SharedCacheUploader spied = createSpiedUploader(resource, localPath, user, conf, scmClient, fs, localFs); Path actualPath = spied.getActualPath(); assertEquals(actualPath.getName(), localPath.getName()); assertEquals(actualPath.getParent().getName(), localPath.getName()); }
public URI buildEncodedUri(String endpointUrl) { if (endpointUrl == null) { throw new RuntimeException("Url string cannot be null!"); } if (endpointUrl.isEmpty()) { throw new RuntimeException("Url string cannot be empty!"); } URI uri = UriComponentsBuilder.fromUriString(endpointUrl).build().encode().toUri(); if (uri.getScheme() == null || uri.getScheme().isEmpty()) { throw new RuntimeException("Transport scheme(protocol) must be provided!"); } boolean authorityNotValid = uri.getAuthority() == null || uri.getAuthority().isEmpty(); boolean hostNotValid = uri.getHost() == null || uri.getHost().isEmpty(); if (authorityNotValid || hostNotValid) { throw new RuntimeException("Url string is invalid!"); } return uri; }
@Test public void testBuildSimpleUri() { Mockito.when(client.buildEncodedUri(any())).thenCallRealMethod(); String url = "http://localhost:8080/"; URI uri = client.buildEncodedUri(url); Assertions.assertEquals(url, uri.toString()); }
@Override public void serialize(Asn1OutputStream out, BigInteger obj) { out.write(BCD.encode(obj)); }
@Test public void shouldSerialize() { assertArrayEquals( new byte[] { 0x13, 0x37 }, serialize(new BcdConverter(), BigInteger.class, BigInteger.valueOf(1337)) ); }
@Produces @DefaultBean @Singleton JobRunrDashboardWebServerConfiguration dashboardWebServerConfiguration() { if (jobRunrBuildTimeConfiguration.dashboard().enabled()) { final JobRunrDashboardWebServerConfiguration dashboardWebServerConfiguration = usingStandardDashboardConfiguration(); jobRunrRuntimeConfiguration.dashboard().port().ifPresent(dashboardWebServerConfiguration::andPort); if (jobRunrRuntimeConfiguration.dashboard().username().isPresent() && jobRunrRuntimeConfiguration.dashboard().password().isPresent()) { dashboardWebServerConfiguration.andBasicAuthentication(jobRunrRuntimeConfiguration.dashboard().username().get(), jobRunrRuntimeConfiguration.dashboard().password().get()); } dashboardWebServerConfiguration.andAllowAnonymousDataUsage(jobRunrRuntimeConfiguration.miscellaneous().allowAnonymousDataUsage()); return dashboardWebServerConfiguration; } return null; }
@Test void dashboardWebServerConfigurationIsSetupWhenConfigured() { when(dashboardBuildTimeConfiguration.enabled()).thenReturn(true); assertThat(jobRunrProducer.dashboardWebServerConfiguration()).isNotNull(); }
@Override public Long del(byte[]... keys) { if (isQueueing() || isPipelined()) { for (byte[] key: keys) { write(key, LongCodec.INSTANCE, RedisCommands.DEL, key); } return null; } CommandBatchService es = new CommandBatchService(executorService); for (byte[] key: keys) { es.writeAsync(key, StringCodec.INSTANCE, RedisCommands.DEL, key); } BatchResult<Long> b = (BatchResult<Long>) es.execute(); return b.getResponses().stream().collect(Collectors.summarizingLong(v -> v)).getSum(); }
@Test public void testDelPipeline() { byte[] k = "key".getBytes(); byte[] v = "val".getBytes(); connection.set(k, v); connection.openPipeline(); connection.get(k); connection.del(k); List<Object> results = connection.closePipeline(); byte[] val = (byte[])results.get(0); assertThat(val).isEqualTo(v); Long res = (Long) results.get(1); assertThat(res).isEqualTo(1); }
public static Optional<Expression> convert( org.apache.flink.table.expressions.Expression flinkExpression) { if (!(flinkExpression instanceof CallExpression)) { return Optional.empty(); } CallExpression call = (CallExpression) flinkExpression; Operation op = FILTERS.get(call.getFunctionDefinition()); if (op != null) { switch (op) { case IS_NULL: return onlyChildAs(call, FieldReferenceExpression.class) .map(FieldReferenceExpression::getName) .map(Expressions::isNull); case NOT_NULL: return onlyChildAs(call, FieldReferenceExpression.class) .map(FieldReferenceExpression::getName) .map(Expressions::notNull); case LT: return convertFieldAndLiteral(Expressions::lessThan, Expressions::greaterThan, call); case LT_EQ: return convertFieldAndLiteral( Expressions::lessThanOrEqual, Expressions::greaterThanOrEqual, call); case GT: return convertFieldAndLiteral(Expressions::greaterThan, Expressions::lessThan, call); case GT_EQ: return convertFieldAndLiteral( Expressions::greaterThanOrEqual, Expressions::lessThanOrEqual, call); case EQ: return convertFieldAndLiteral( (ref, lit) -> { if (NaNUtil.isNaN(lit)) { return Expressions.isNaN(ref); } else { return Expressions.equal(ref, lit); } }, call); case NOT_EQ: return convertFieldAndLiteral( (ref, lit) -> { if (NaNUtil.isNaN(lit)) { return Expressions.notNaN(ref); } else { return Expressions.notEqual(ref, lit); } }, call); case NOT: return onlyChildAs(call, CallExpression.class) .flatMap(FlinkFilters::convert) .map(Expressions::not); case AND: return convertLogicExpression(Expressions::and, call); case OR: return convertLogicExpression(Expressions::or, call); case STARTS_WITH: return convertLike(call); } } return Optional.empty(); }
@Test public void testLike() { UnboundPredicate<?> expected = org.apache.iceberg.expressions.Expressions.startsWith("field5", "abc"); Expression expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("abc%"))); Optional<org.apache.iceberg.expressions.Expression> actual = FlinkFilters.convert(expr); assertThat(actual).isPresent(); assertPredicatesMatch(expected, actual.get()); expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("%abc"))); actual = FlinkFilters.convert(expr); assertThat(actual).isNotPresent(); expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("%abc%"))); actual = FlinkFilters.convert(expr); assertThat(actual).isNotPresent(); expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("abc%d"))); actual = FlinkFilters.convert(expr); assertThat(actual).isNotPresent(); expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("%"))); actual = FlinkFilters.convert(expr); assertThat(actual).isNotPresent(); expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("a_"))); actual = FlinkFilters.convert(expr); assertThat(actual).isNotPresent(); expr = resolve( ApiExpressionUtils.unresolvedCall( BuiltInFunctionDefinitions.LIKE, Expressions.$("field5"), Expressions.lit("a%b"))); actual = FlinkFilters.convert(expr); assertThat(actual).isNotPresent(); }
public static int toIntSize(long size) { assert size >= 0 : "Invalid size value: " + size; return size > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) size; }
@Test public void toIntSize_whenLessThanIntMax() { long size = 123456789; assertEquals((int) size, toIntSize(size)); }
public boolean isAbilitySupportedByServer(AbilityKey abilityKey) { return rpcClient.getConnectionAbility(abilityKey) == AbilityStatus.SUPPORTED; }
@Test void testIsAbilitySupportedByServer3() { when(this.rpcClient.getConnectionAbility(AbilityKey.SERVER_SUPPORT_PERSISTENT_INSTANCE_BY_GRPC)).thenReturn( AbilityStatus.UNKNOWN); assertFalse(client.isAbilitySupportedByServer(AbilityKey.SERVER_SUPPORT_PERSISTENT_INSTANCE_BY_GRPC)); verify(this.rpcClient, times(1)).getConnectionAbility(AbilityKey.SERVER_SUPPORT_PERSISTENT_INSTANCE_BY_GRPC); }
public static FileMetaData readFileMetaData(InputStream from) throws IOException { return readFileMetaData(from, null, null); }
@Test public void testReadFileMetadata() throws Exception { ByteArrayOutputStream baos = new ByteArrayOutputStream(); FileMetaData md = new FileMetaData( 1, asList(new SchemaElement("foo")), 10, asList( new RowGroup(asList(new ColumnChunk(0), new ColumnChunk(1)), 10, 5), new RowGroup(asList(new ColumnChunk(2), new ColumnChunk(3)), 11, 5))); writeFileMetaData(md, baos); FileMetaData md2 = readFileMetaData(in(baos)); FileMetaData md3 = new FileMetaData(); readFileMetaData(in(baos), new DefaultFileMetaDataConsumer(md3)); FileMetaData md4 = new FileMetaData(); readFileMetaData(in(baos), new DefaultFileMetaDataConsumer(md4), true); FileMetaData md5 = readFileMetaData(in(baos), true); FileMetaData md6 = readFileMetaData(in(baos), false); assertEquals(md, md2); assertEquals(md, md3); assertNull(md4.getRow_groups()); assertNull(md5.getRow_groups()); assertEquals(md4, md5); md4.setRow_groups(md.getRow_groups()); md5.setRow_groups(md.getRow_groups()); assertEquals(md, md4); assertEquals(md, md5); assertEquals(md4, md5); assertEquals(md, md6); }
public static void getSemanticPropsSingleFromString( SingleInputSemanticProperties result, String[] forwarded, String[] nonForwarded, String[] readSet, TypeInformation<?> inType, TypeInformation<?> outType) { getSemanticPropsSingleFromString( result, forwarded, nonForwarded, readSet, inType, outType, false); }
@Test void testForwardedWildCardInvalidTypes3() { String[] forwardedFields = {"*"}; SingleInputSemanticProperties sp = new SingleInputSemanticProperties(); assertThatThrownBy( () -> SemanticPropUtil.getSemanticPropsSingleFromString( sp, forwardedFields, null, null, pojoType, pojo2Type)) .isInstanceOf(InvalidSemanticAnnotationException.class); }
@Override protected void runAfterCatalogReady() { try { process(); } catch (Throwable e) { LOG.warn("Failed to process one round of RoutineLoadScheduler", e); } }
@Test public void testEmptyTaskQueue(@Injectable RoutineLoadMgr routineLoadManager) { RoutineLoadTaskScheduler routineLoadTaskScheduler = new RoutineLoadTaskScheduler(routineLoadManager); new Expectations() { { routineLoadManager.getClusterIdleSlotNum(); result = 1; times = 1; } }; routineLoadTaskScheduler.runAfterCatalogReady(); }
@VisibleForTesting static SingleSegmentAssignment getNextSingleSegmentAssignment(Map<String, String> currentInstanceStateMap, Map<String, String> targetInstanceStateMap, int minAvailableReplicas, boolean lowDiskMode, Map<String, Integer> numSegmentsToOffloadMap, Map<Pair<Set<String>, Set<String>>, Set<String>> assignmentMap) { Map<String, String> nextInstanceStateMap = new TreeMap<>(); // Assign the segment the same way as other segments if the current and target instances are the same. We need this // to guarantee the mirror servers for replica-group based routing strategies. Set<String> currentInstances = currentInstanceStateMap.keySet(); Set<String> targetInstances = targetInstanceStateMap.keySet(); Pair<Set<String>, Set<String>> assignmentKey = Pair.of(currentInstances, targetInstances); Set<String> instancesToAssign = assignmentMap.get(assignmentKey); if (instancesToAssign != null) { Set<String> availableInstances = new TreeSet<>(); for (String instanceName : instancesToAssign) { String currentInstanceState = currentInstanceStateMap.get(instanceName); String targetInstanceState = targetInstanceStateMap.get(instanceName); if (currentInstanceState != null) { availableInstances.add(instanceName); // Use target instance state if available in case the state changes nextInstanceStateMap.put(instanceName, targetInstanceState != null ? targetInstanceState : currentInstanceState); } else { nextInstanceStateMap.put(instanceName, targetInstanceState); } } return new SingleSegmentAssignment(nextInstanceStateMap, availableInstances); } // Add all the common instances // Use target instance state in case the state changes for (Map.Entry<String, String> entry : targetInstanceStateMap.entrySet()) { String instanceName = entry.getKey(); if (currentInstanceStateMap.containsKey(instanceName)) { nextInstanceStateMap.put(instanceName, entry.getValue()); } } // Add current instances until the min available replicas achieved int numInstancesToKeep = minAvailableReplicas - nextInstanceStateMap.size(); if (numInstancesToKeep > 0) { // Sort instances by number of segments to offload, and keep the ones with the least segments to offload List<Triple<String, String, Integer>> instancesInfo = getSortedInstancesOnNumSegmentsToOffload(currentInstanceStateMap, nextInstanceStateMap, numSegmentsToOffloadMap); numInstancesToKeep = Integer.min(numInstancesToKeep, instancesInfo.size()); for (int i = 0; i < numInstancesToKeep; i++) { Triple<String, String, Integer> instanceInfo = instancesInfo.get(i); nextInstanceStateMap.put(instanceInfo.getLeft(), instanceInfo.getMiddle()); } } Set<String> availableInstances = new TreeSet<>(nextInstanceStateMap.keySet()); // After achieving the min available replicas, when low disk mode is enabled, only add new instances when all // current instances exist in the next assignment. // We want to first drop the extra instances as one step, then add the target instances as another step to avoid the // case where segments are first added to the instance before other segments are dropped from the instance, which // might cause server running out of disk. Note that even if segment addition and drop happen in the same step, // there is no guarantee that server process the segment drop before the segment addition. if (!lowDiskMode || currentInstanceStateMap.size() == nextInstanceStateMap.size()) { int numInstancesToAdd = targetInstanceStateMap.size() - nextInstanceStateMap.size(); if (numInstancesToAdd > 0) { // Sort instances by number of segments to offload, and add the ones with the least segments to offload List<Triple<String, String, Integer>> instancesInfo = getSortedInstancesOnNumSegmentsToOffload(targetInstanceStateMap, nextInstanceStateMap, numSegmentsToOffloadMap); for (int i = 0; i < numInstancesToAdd; i++) { Triple<String, String, Integer> instanceInfo = instancesInfo.get(i); nextInstanceStateMap.put(instanceInfo.getLeft(), instanceInfo.getMiddle()); } } } assignmentMap.put(assignmentKey, nextInstanceStateMap.keySet()); return new SingleSegmentAssignment(nextInstanceStateMap, availableInstances); }
@Test public void testOneMinAvailableReplicasWithLowDiskMode() { // With 2 common instances, first assignment should keep the common instances and remove the not common instance Map<String, String> currentInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host2", "host3"), ONLINE); Map<String, String> targetInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host2", "host4"), ONLINE); TableRebalancer.SingleSegmentAssignment assignment = getNextSingleSegmentAssignment(currentInstanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host2"), ONLINE)); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host1", "host2"))); // Second assignment should be the same as target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, targetInstanceStateMap); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host1", "host2"))); // With 1 common instance, first assignment should keep the common instance and remove the not common instances targetInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host4", "host5"), ONLINE); assignment = getNextSingleSegmentAssignment(currentInstanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, Collections.singletonMap("host1", ONLINE)); assertEquals(assignment._availableInstances, Collections.singletonList("host1")); // Second assignment should be the same as target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, targetInstanceStateMap); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Without common instance, fist assignment should keep 1 instance from current assignment targetInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host4", "host5", "host6"), ONLINE); assignment = getNextSingleSegmentAssignment(currentInstanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, Collections.singletonMap("host1", ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Second assignment should add 2 instances from target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host4", "host5"), ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Third assignment should remove the old instance from current assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host4", "host5"), ONLINE)); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host4", "host5"))); // Fourth assignment should make the assignment the same as target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, targetInstanceStateMap); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host4", "host5"))); // With increasing number of replicas, fist assignment should keep 1 instance from current assignment targetInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host4", "host5", "host6", "host7"), ONLINE); assignment = getNextSingleSegmentAssignment(currentInstanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, Collections.singletonMap("host1", ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Second assignment should add 3 instances from target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host4", "host5", "host6"), ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Third assignment should remove the old instance from current assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host4", "host5", "host6"), ONLINE)); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host4", "host5", "host6"))); // Fourth assignment should make the assignment the same as target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, targetInstanceStateMap); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host4", "host5", "host6"))); // With decreasing number of replicas, fist assignment should keep 1 instance from current assignment currentInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host2", "host3", "host4"), ONLINE); targetInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host5", "host6", "host7"), ONLINE); assignment = getNextSingleSegmentAssignment(currentInstanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, Collections.singletonMap("host1", ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Second assignment should add 2 instances from target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host5", "host6"), ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Third assignment should remove the old instance from current assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host5", "host6"), ONLINE)); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host5", "host6"))); // Fourth assignment should make the assignment the same as target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, targetInstanceStateMap); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host5", "host6"))); // With increasing from 1 replica, fist assignment should keep the instance from current assignment, and add 2 // instances from target assignment currentInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Collections.singletonList("host1"), ONLINE); targetInstanceStateMap = SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host2", "host3", "host4"), ONLINE); assignment = getNextSingleSegmentAssignment(currentInstanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host1", "host2", "host3"), ONLINE)); assertEquals(assignment._availableInstances, Collections.singleton("host1")); // Second assignment should remove the old instance from current assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, SegmentAssignmentUtils.getInstanceStateMap(Arrays.asList("host2", "host3"), ONLINE)); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host2", "host3"))); // Third assignment should make the assignment the same as target assignment assignment = getNextSingleSegmentAssignment(assignment._instanceStateMap, targetInstanceStateMap, 1, true); assertEquals(assignment._instanceStateMap, targetInstanceStateMap); assertEquals(assignment._availableInstances, new TreeSet<>(Arrays.asList("host2", "host3"))); }
static Time toTime(final JsonNode object) { if (object instanceof NumericNode) { return returnTimeOrThrow(object.asLong()); } if (object instanceof TextNode) { try { return returnTimeOrThrow(Long.parseLong(object.textValue())); } catch (final NumberFormatException e) { throw failedStringCoercionException(SqlBaseType.TIME); } } throw invalidConversionException(object, SqlBaseType.TIME); }
@Test(expected = IllegalArgumentException.class) public void shouldFailWhenConvertingIncompatibleTime() { JsonSerdeUtils.toTime(JsonNodeFactory.instance.booleanNode(false)); }
public static boolean isChineseName(CharSequence value) { return isMatchRegex(PatternPool.CHINESE_NAME, value); }
@Test public void isChineseNameTest() { assertTrue(Validator.isChineseName("阿卜杜尼亚孜·毛力尼亚孜")); assertFalse(Validator.isChineseName("阿卜杜尼亚孜./毛力尼亚孜")); assertTrue(Validator.isChineseName("段正淳")); assertFalse(Validator.isChineseName("孟 伟")); assertFalse(Validator.isChineseName("李")); assertFalse(Validator.isChineseName("连逍遥0")); assertFalse(Validator.isChineseName("SHE")); }
@PreAuthorize("hasAnyAuthority('SYS_ADMIN', 'TENANT_ADMIN')") @PutMapping(IMAGE_URL + "/info") public TbResourceInfo updateImageInfo(@Parameter(description = IMAGE_TYPE_PARAM_DESCRIPTION, schema = @Schema(allowableValues = {"tenant", "system"}), required = true) @PathVariable String type, @Parameter(description = IMAGE_KEY_PARAM_DESCRIPTION, required = true) @PathVariable String key, @RequestBody TbResourceInfo request) throws ThingsboardException { TbResourceInfo imageInfo = checkImageInfo(type, key, Operation.WRITE); TbResourceInfo newImageInfo = new TbResourceInfo(imageInfo); newImageInfo.setTitle(request.getTitle()); return tbImageService.save(newImageInfo, imageInfo, getCurrentUser()); }
@Test public void testUpdateImageInfo() throws Exception { String filename = "my_png_image.png"; TbResourceInfo imageInfo = uploadImage(HttpMethod.POST, "/api/image", filename, "image/png", PNG_IMAGE); ImageDescriptor imageDescriptor = imageInfo.getDescriptor(ImageDescriptor.class); assertThat(imageInfo.getTitle()).isEqualTo(filename); assertThat(imageInfo.getResourceKey()).isEqualTo(filename); assertThat(imageInfo.getFileName()).isEqualTo(filename); String newTitle = "My PNG image"; TbResourceInfo newImageInfo = new TbResourceInfo(imageInfo); newImageInfo.setTitle(newTitle); newImageInfo.setDescriptor(JacksonUtil.newObjectNode()); newImageInfo = doPut("/api/images/tenant/" + filename + "/info", newImageInfo, TbResourceInfo.class); assertThat(newImageInfo.getTitle()).isEqualTo(newTitle); assertThat(newImageInfo.getDescriptor(ImageDescriptor.class)).isEqualTo(imageDescriptor); assertThat(newImageInfo.getResourceKey()).isEqualTo(imageInfo.getResourceKey()); assertThat(newImageInfo.getPublicResourceKey()).isEqualTo(newImageInfo.getPublicResourceKey()); }
public void cacheRuleData(final String path, final RuleData ruleData, final int initialCapacity, final long maximumSize) { MapUtils.computeIfAbsent(RULE_DATA_MAP, ruleData.getPluginName(), map -> new WindowTinyLFUMap<>(initialCapacity, maximumSize, Boolean.FALSE)).put(path, ruleData); }
@Test public void testCacheRuleData() throws NoSuchFieldException, IllegalAccessException { RuleData cacheRuleData = RuleData.builder().id("1").pluginName(mockPluginName1).sort(1).build(); MatchDataCache.getInstance().cacheRuleData(path1, cacheRuleData, 100, 100); ConcurrentHashMap<String, WindowTinyLFUMap<String, RuleData>> ruleMap = getFieldByName(ruleMapStr); assertEquals(cacheRuleData, ruleMap.get(mockPluginName1).get(path1)); ruleMap.clear(); }
public static String UU32(java.util.UUID uu) { StringBuilder sb = new StringBuilder(); long m = uu.getMostSignificantBits(); long l = uu.getLeastSignificantBits(); for (int i = 0; i < 13; i++) { sb.append(_UU32[(int) (m >> ((13 - i - 1) * 5)) & 31]); } for (int i = 0; i < 13; i++) { sb.append(_UU32[(int) (l >> ((13 - i - 1)) * 5) & 31]); } return sb.toString(); }
@Test public void testUU32(){ String uu32 = UUID.UU32(); System.out.println(uu32); }
@Override public void readFrame(ChannelHandlerContext ctx, ByteBuf input, Http2FrameListener listener) throws Http2Exception { if (readError) { input.skipBytes(input.readableBytes()); return; } try { do { if (readingHeaders && !preProcessFrame(input)) { return; } // The header is complete, fall into the next case to process the payload. // This is to ensure the proper handling of zero-length payloads. In this // case, we don't want to loop around because there may be no more data // available, causing us to exit the loop. Instead, we just want to perform // the first pass at payload processing now. // Wait until the entire payload has been read. if (input.readableBytes() < payloadLength) { return; } // Slice to work only on the frame being read ByteBuf framePayload = input.readSlice(payloadLength); // We have consumed the data for this frame, next time we read, // we will be expecting to read a new frame header. readingHeaders = true; verifyFrameState(); processPayloadState(ctx, framePayload, listener); } while (input.isReadable()); } catch (Http2Exception e) { readError = !Http2Exception.isStreamError(e); throw e; } catch (RuntimeException e) { readError = true; throw e; } catch (Throwable cause) { readError = true; PlatformDependent.throwException(cause); } }
@Test public void failedWhenSettingsFrameOnNonZeroStream() throws Http2Exception { final ByteBuf input = Unpooled.buffer(); try { writeFrameHeader(input, 6, SETTINGS, new Http2Flags(), 1); input.writeShort(SETTINGS_MAX_HEADER_LIST_SIZE); input.writeInt(1024); Http2Exception ex = assertThrows(Http2Exception.class, new Executable() { @Override public void execute() throws Throwable { frameReader.readFrame(ctx, input, listener); } }); assertFalse(ex instanceof Http2Exception.StreamException); } finally { input.release(); } }
public Document process(Document input) throws TransformerException { Document doc = Xml.copyDocument(input); Document document = buildProperties(doc); applyProperties(document.getDocumentElement()); return document; }
@Test public void testWarnIfDuplicatePropertyForSameEnvironment() throws TransformerException { String input = """ <?xml version="1.0" encoding="UTF-8" standalone="no"?> <services xmlns:deploy="vespa" xmlns:preprocess="properties" version="1.0"> <preprocess:properties> <slobrok.port>4099</slobrok.port> <slobrok.port>5000</slobrok.port> <redundancy>2</redundancy> </preprocess:properties> <admin version="2.0"> <adminserver hostalias="node0"/> <slobroks> <slobrok hostalias="node1" baseport="${slobrok.port}"/> </slobroks> </admin> </services>"""; // Should get the last defined value String expected = """ <?xml version="1.0" encoding="UTF-8" standalone="no"?> <services xmlns:deploy="vespa" xmlns:preprocess="properties" version="1.0"> <admin version="2.0"> <adminserver hostalias="node0"/> <slobroks> <slobrok hostalias="node1" baseport="5000"/> </slobroks> </admin> </services>"""; Document inputDoc = Xml.getDocument(new StringReader(input)); Document newDoc = new PropertiesProcessor().process(inputDoc); TestBase.assertDocument(expected, newDoc); }
Converter<E> compile() { head = tail = null; for (Node n = top; n != null; n = n.next) { switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if(compositeConverter == null) { addError("Failed to create converter for [%"+cn.getValue()+"] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR["+cn.getValue()+"]")); break; } compositeConverter.setFormattingInfo(cn.getFormatInfo()); compositeConverter.setOptionList(cn.getOptions()); Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { // if the appropriate dynaconverter cannot be found, then replace // it with a dummy LiteralConverter indicating an error. Converter<E> errConveter = new LiteralConverter<E>("%PARSER_ERROR[" + kn.getValue() + "]"); addStatus(new ErrorStatus("[" + kn.getValue() + "] is not a valid conversion word", this)); addToList(errConveter); } } } return head; }
@Test public void testWithNopEscape() throws Exception { { Parser<Object> p = new Parser<Object>("xyz %hello\\_world"); p.setContext(context); Node t = p.parse(); Converter<Object> head = p.compile(t, converterMap); String result = write(head, new Object()); assertEquals("xyz Helloworld", result); } }
@Override public void onDraw(Canvas canvas) { final boolean keyboardChanged = mKeyboardChanged; super.onDraw(canvas); // switching animation if (mAnimationLevel != AnimationsLevel.None && keyboardChanged && (mInAnimation != null)) { startAnimation(mInAnimation); mInAnimation = null; } if (mGestureTypingPathShouldBeDrawn) { mGestureDrawingHelper.draw(canvas); } // showing any requested watermark float watermarkX = mWatermarkEdgeX; final float watermarkY = getHeight() - mWatermarkDimen - mWatermarkMargin; for (Drawable watermark : mWatermarks) { watermarkX -= (mWatermarkDimen + mWatermarkMargin); canvas.translate(watermarkX, watermarkY); watermark.draw(canvas); canvas.translate(-watermarkX, -watermarkY); } }
@Test public void testDoesNotAddExtraDrawIfAnimationsAreOff() { SharedPrefsHelper.setPrefsValue(R.string.settings_key_tweak_animations_level, "none"); ExtraDraw mockDraw1 = Mockito.mock(ExtraDraw.class); Mockito.doReturn(true).when(mockDraw1).onDraw(any(), any(), same(mViewUnderTest)); Robolectric.getForegroundThreadScheduler().pause(); Assert.assertFalse(Robolectric.getForegroundThreadScheduler().areAnyRunnable()); mViewUnderTest.addExtraDraw(mockDraw1); Mockito.verify(mockDraw1, Mockito.never()).onDraw(any(), any(), any()); Assert.assertEquals(0, Robolectric.getForegroundThreadScheduler().size()); }
@Override public String toString() { return "MetadataVersionChange(" + "oldVersion=" + oldVersion + ", newVersion=" + newVersion + ")"; }
@Test public void testMetadataVersionChangeExceptionToString() { assertEquals("org.apache.kafka.image.MetadataVersionChangeException: The metadata.version " + "is changing from 3.0-IV1 to 3.3-IV0", new MetadataVersionChangeException(CHANGE_3_0_IV1_TO_3_3_IV0).toString()); assertEquals("org.apache.kafka.image.MetadataVersionChangeException: The metadata.version " + "is changing from 3.3-IV0 to 3.0-IV1", new MetadataVersionChangeException(CHANGE_3_3_IV0_TO_3_0_IV1).toString()); }
@Override public boolean onTouchEvent(@NonNull MotionEvent nativeMotionEvent) { if (mKeyboard == null) { // I mean, if there isn't any keyboard I'm handling, what's the point? return false; } final int action = nativeMotionEvent.getActionMasked(); final int pointerCount = nativeMotionEvent.getPointerCount(); if (pointerCount > 1) { mLastTimeHadTwoFingers = SystemClock.elapsedRealtime(); // marking the time. Read isAtTwoFingersState() } if (mTouchesAreDisabledTillLastFingerIsUp) { if (!areTouchesDisabled(nativeMotionEvent) /*this means it was just reset*/) { mTouchesAreDisabledTillLastFingerIsUp = false; // continue with onTouchEvent flow. if (action != MotionEvent.ACTION_DOWN) { // swallowing the event. // in case this is a DOWN event, we do want to pass it return true; } } else { // swallowing touch event until we reset mTouchesAreDisabledTillLastFingerIsUp return true; } } final long eventTime = nativeMotionEvent.getEventTime(); final int index = nativeMotionEvent.getActionIndex(); final int id = nativeMotionEvent.getPointerId(index); final int x = (int) nativeMotionEvent.getX(index); final int y = (int) nativeMotionEvent.getY(index); if (mKeyPressTimingHandler.isInKeyRepeat()) { // It will keep being in the key repeating mode while the key is // being pressed. if (action == MotionEvent.ACTION_MOVE) { return true; } final PointerTracker tracker = getPointerTracker(id); // Key repeating timer will be canceled if 2 or more keys are in // action, and current // event (UP or DOWN) is non-modifier key. if (pointerCount > 1 && !tracker.isModifier()) { mKeyPressTimingHandler.cancelKeyRepeatTimer(); } // Up event will pass through. } if (action == MotionEvent.ACTION_MOVE) { for (int i = 0; i < pointerCount; i++) { PointerTracker tracker = getPointerTracker(nativeMotionEvent.getPointerId(i)); tracker.onMoveEvent( (int) nativeMotionEvent.getX(i), (int) nativeMotionEvent.getY(i), eventTime); } } else { PointerTracker tracker = getPointerTracker(id); sendOnXEvent(action, eventTime, x, y, tracker); } return true; }
@Test public void testRegularPressKeyPressState() { final Keyboard.Key key = findKey('f'); KeyDrawableStateProvider provider = new KeyDrawableStateProvider( R.attr.key_type_function, R.attr.key_type_action, R.attr.action_done, R.attr.action_search, R.attr.action_go); Assert.assertArrayEquals(provider.KEY_STATE_NORMAL, key.getCurrentDrawableState(provider)); Point keyPoint = ViewTestUtils.getKeyCenterPoint(key); ViewTestUtils.navigateFromTo(mUnderTest, keyPoint, keyPoint, 60, true, false); Assert.assertArrayEquals(provider.KEY_STATE_PRESSED, key.getCurrentDrawableState(provider)); mUnderTest.onTouchEvent( MotionEvent.obtain( SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP, keyPoint.x, keyPoint.y, 0)); Assert.assertArrayEquals(provider.KEY_STATE_NORMAL, key.getCurrentDrawableState(provider)); }
public boolean sendHeartbeatToBroker(long id, String brokerName, String addr) { if (this.lockHeartbeat.tryLock()) { final HeartbeatData heartbeatDataWithSub = this.prepareHeartbeatData(false); final boolean producerEmpty = heartbeatDataWithSub.getProducerDataSet().isEmpty(); final boolean consumerEmpty = heartbeatDataWithSub.getConsumerDataSet().isEmpty(); if (producerEmpty && consumerEmpty) { log.warn("sendHeartbeatToBroker sending heartbeat, but no consumer and no producer. [{}]", this.clientId); return false; } try { if (clientConfig.isUseHeartbeatV2()) { int currentHeartbeatFingerprint = heartbeatDataWithSub.computeHeartbeatFingerprint(); heartbeatDataWithSub.setHeartbeatFingerprint(currentHeartbeatFingerprint); HeartbeatData heartbeatDataWithoutSub = this.prepareHeartbeatData(true); heartbeatDataWithoutSub.setHeartbeatFingerprint(currentHeartbeatFingerprint); return this.sendHeartbeatToBrokerV2(id, brokerName, addr, heartbeatDataWithSub, heartbeatDataWithoutSub, currentHeartbeatFingerprint); } else { return this.sendHeartbeatToBroker(id, brokerName, addr, heartbeatDataWithSub); } } catch (final Exception e) { log.error("sendHeartbeatToAllBroker exception", e); } finally { this.lockHeartbeat.unlock(); } } else { log.warn("lock heartBeat, but failed. [{}]", this.clientId); } return false; }
@Test public void testSendHeartbeatToBrokerV1() { consumerTable.put(group, createMQConsumerInner()); assertTrue(mqClientInstance.sendHeartbeatToBroker(0L, defaultBroker, defaultBrokerAddr)); }
public ColumnConstraints getConstraints() { return constraints; }
@Test public void shouldReturnKeyConstraint() { // Given: final TableElement valueElement = new TableElement(NAME, new Type(SqlTypes.STRING), KEY_CONSTRAINT); // Then: assertThat(valueElement.getConstraints(), is(KEY_CONSTRAINT)); }
public static Builder withSchema(Schema schema) { return new Builder(schema); }
@Test public void testCreateWithCollectionNames() { Schema type = Stream.of( Schema.Field.of("f_array", FieldType.array(FieldType.INT32)), Schema.Field.of("f_iterable", FieldType.iterable(FieldType.INT32)), Schema.Field.of("f_map", FieldType.map(FieldType.STRING, FieldType.STRING))) .collect(toSchema()); Row row = Row.withSchema(type) .withFieldValue("f_array", ImmutableList.of(1, 2, 3)) .withFieldValue("f_iterable", ImmutableList.of(1, 2, 3)) .withFieldValue("f_map", ImmutableMap.of("one", "two")) .build(); Row expectedRow = Row.withSchema(type) .addValues( ImmutableList.of(1, 2, 3), ImmutableList.of(1, 2, 3), ImmutableMap.of("one", "two")) .build(); assertEquals(expectedRow, row); }
@Override public boolean postpone( String queueName, String messageId, int priority, long postponeDurationInSeconds) { remove(queueName, messageId); push(queueName, messageId, priority, postponeDurationInSeconds); return true; }
@Test public void testPostpone() { String queueName = "test-queue"; String id = "abcd-1234-defg-5678"; assertTrue(queueDao.postpone(queueName, id, 0, 0)); assertEquals(1, internalQueue.size()); assertEquals(1, internalQueue.get(queueName).size()); assertEquals(id, internalQueue.get(queueName).peek()); }
Single<Post> save(Post post) { Post saved = Post.builder().id(UUID.randomUUID()).title(post.getTitle()).content(post.getContent()).build(); DATA.add(saved); return Single.just(saved); }
@Test void save() { var testObserver = new TestObserver<Post>(); this.posts.save(Post.builder().title("test title").content("test content").build()) .subscribe(testObserver); testObserver.assertComplete(); testObserver.assertNoErrors(); testObserver.assertValue(p -> null != p.getId()); }
@Override public void render(Node node, Appendable output) { RendererContext context = new RendererContext(new MarkdownWriter(output)); context.render(node); }
@Test public void testBulletListItemsFromAst() { var doc = new Document(); var list = new BulletList(); var item = new ListItem(); item.appendChild(new Text("Test")); list.appendChild(item); doc.appendChild(list); assertRendering("", "- Test\n", render(doc)); list.setMarker("*"); assertRendering("", "* Test\n", render(doc)); }
public double[][] test(DataFrame data) { DataFrame x = formula.x(data); int n = x.nrow(); int ntrees = trees.length; double[][] prediction = new double[ntrees][n]; for (int j = 0; j < n; j++) { Tuple xj = x.get(j); double base = b; for (int i = 0; i < ntrees; i++) { base += shrinkage * trees[i].predict(xj); prediction[i][j] = base; } } return prediction; }
@Test public void testKin8nmHuber() { test(Loss.huber(0.9), "kin8nm", Kin8nm.formula, Kin8nm.data, 0.1795); }
public void resetOffsetsTo(final Consumer<byte[], byte[]> client, final Set<TopicPartition> inputTopicPartitions, final Long offset) { final Map<TopicPartition, Long> endOffsets = client.endOffsets(inputTopicPartitions); final Map<TopicPartition, Long> beginningOffsets = client.beginningOffsets(inputTopicPartitions); final Map<TopicPartition, Long> topicPartitionsAndOffset = new HashMap<>(inputTopicPartitions.size()); for (final TopicPartition topicPartition : inputTopicPartitions) { topicPartitionsAndOffset.put(topicPartition, offset); } final Map<TopicPartition, Long> validatedTopicPartitionsAndOffset = checkOffsetRange(topicPartitionsAndOffset, beginningOffsets, endOffsets); for (final TopicPartition topicPartition : inputTopicPartitions) { client.seek(topicPartition, validatedTopicPartitionsAndOffset.get(topicPartition)); } }
@Test public void testResetToSpecificOffsetWhenBeforeBeginningOffset() { final Map<TopicPartition, Long> endOffsets = new HashMap<>(); endOffsets.put(topicPartition, 4L); consumer.updateEndOffsets(endOffsets); final Map<TopicPartition, Long> beginningOffsets = new HashMap<>(); beginningOffsets.put(topicPartition, 3L); consumer.updateBeginningOffsets(beginningOffsets); streamsResetter.resetOffsetsTo(consumer, inputTopicPartitions, 2L); final ConsumerRecords<byte[], byte[]> records = consumer.poll(Duration.ofMillis(500)); assertEquals(2, records.count()); }
@Override public boolean needLoad() { try { Class.forName("com.alipay.lookout.spi.MetricsImporterLocator"); return true; } catch (Exception e) { return false; } }
@Test public void testNeedLoad() { LookoutModule lookoutModule = new LookoutModule(); Assert.assertEquals(true, lookoutModule.needLoad()); }
@Override public boolean match(final String rule) { return rule.matches("^phone$"); }
@Test void match() { assertTrue(generator.match("phone")); assertFalse(generator.match("mobile")); }
@Override @NonNull public Predicate<E> convert(SelectorCriteria criteria) { return ext -> { var labels = ext.getMetadata().getLabels(); switch (criteria.operator()) { case Equals -> { if (labels == null || !labels.containsKey(criteria.key())) { return false; } return criteria.values().contains(labels.get(criteria.key())); } case NotEquals -> { if (labels == null || !labels.containsKey(criteria.key())) { return false; } return !criteria.values().contains(labels.get(criteria.key())); } case NotExist -> { return labels == null || !labels.containsKey(criteria.key()); } case Exist -> { return labels != null && labels.containsKey(criteria.key()); } default -> { return false; } } }; }
@Test void shouldConvertNotEqualsCorrectly() { var criteria = new SelectorCriteria("name", Operator.NotEquals, Set.of("value1", "value2")); var predicate = convert.convert(criteria); assertNotNull(predicate); var fakeExt = new FakeExtension(); var metadata = new Metadata(); fakeExt.setMetadata(metadata); assertFalse(predicate.test(fakeExt)); metadata.setLabels(Map.of("name", "value")); assertTrue(predicate.test(fakeExt)); metadata.setLabels(Map.of("name", "value1")); assertFalse(predicate.test(fakeExt)); metadata.setLabels(Map.of("name", "value2")); assertFalse(predicate.test(fakeExt)); }
static long toLong(final JsonNode object) { if (object instanceof NumericNode) { return object.asLong(); } if (object instanceof TextNode) { try { return Long.parseLong(object.textValue()); } catch (final NumberFormatException e) { throw failedStringCoercionException(SqlBaseType.BIGINT); } } throw invalidConversionException(object, SqlBaseType.BIGINT); }
@Test public void shouldConvertToLongCorrectly() { final Long l = JsonSerdeUtils.toLong(JsonNodeFactory.instance.numberNode(1L)); assertThat(l, equalTo(1L)); }
public static ExpressionTree parseFilterTree(String filter) throws MetaException { return PartFilterParser.parseFilter(filter); }
@Test public void testDateColumnNameKeyword() throws MetaException { MetaException exception = assertThrows(MetaException.class, () -> PartFilterExprUtil.parseFilterTree("date='1990-11-10'")); assertTrue(exception.getMessage().contains("Error parsing partition filter")); }
public static Number jsToNumber( Object value, String classType ) { if ( classType.equalsIgnoreCase( JS_UNDEFINED ) ) { return null; } else if ( classType.equalsIgnoreCase( JS_NATIVE_JAVA_OBJ ) ) { try { // Is it a java Value class ? Value v = (Value) Context.jsToJava( value, Value.class ); return v.getNumber(); } catch ( Exception e ) { String string = Context.toString( value ); return Double.parseDouble( Const.trim( string ) ); } } else if ( classType.equalsIgnoreCase( JS_NATIVE_NUM ) ) { Number nb = Context.toNumber( value ); return nb.doubleValue(); } else { Number nb = (Number) value; return nb.doubleValue(); } }
@Test public void jsToNumber_Undefined() throws Exception { assertNull( JavaScriptUtils.jsToNumber( null, UNDEFINED ) ); }
@Nullable public Supplier<? extends SocketAddress> bindAddressSupplier() { return bindAddressSupplier; }
@Test void bindAddressSupplier() { assertThat(builder.build().bindAddressSupplier()).isNull(); Supplier<SocketAddress> addressSupplier = () -> new InetSocketAddress("localhost", 9527); builder.bindAddressSupplier(addressSupplier); assertThat(builder.build().bindAddressSupplier()).isEqualTo(addressSupplier); }
public static String from(Query query) { if (query instanceof SqmInterpretationsKey.InterpretationsKeySource && query instanceof QueryImplementor && query instanceof QuerySqmImpl) { QueryInterpretationCache.Key cacheKey = SqmInterpretationsKey.createInterpretationsKey((SqmInterpretationsKey.InterpretationsKeySource) query); QuerySqmImpl querySqm = (QuerySqmImpl) query; Supplier buildSelectQueryPlan = () -> ReflectionUtils.invokeMethod(querySqm, "buildSelectQueryPlan"); SelectQueryPlan plan = cacheKey != null ? ((QueryImplementor) query).getSession().getFactory().getQueryEngine() .getInterpretationCache() .resolveSelectQueryPlan(cacheKey, buildSelectQueryPlan) : (SelectQueryPlan) buildSelectQueryPlan.get(); if (plan instanceof ConcreteSqmSelectQueryPlan) { ConcreteSqmSelectQueryPlan selectQueryPlan = (ConcreteSqmSelectQueryPlan) plan; Object cacheableSqmInterpretation = ReflectionUtils.getFieldValueOrNull(selectQueryPlan, "cacheableSqmInterpretation"); if (cacheableSqmInterpretation == null) { DomainQueryExecutionContext domainQueryExecutionContext = DomainQueryExecutionContext.class.cast(querySqm); cacheableSqmInterpretation = ReflectionUtils.invokeStaticMethod( ReflectionUtils.getMethod( ConcreteSqmSelectQueryPlan.class, "buildCacheableSqmInterpretation", SqmSelectStatement.class, DomainParameterXref.class, DomainQueryExecutionContext.class ), ReflectionUtils.getFieldValueOrNull(selectQueryPlan, "sqm"), ReflectionUtils.getFieldValueOrNull(selectQueryPlan, "domainParameterXref"), domainQueryExecutionContext ); } if (cacheableSqmInterpretation != null) { JdbcSelect jdbcSelect = ReflectionUtils.getFieldValueOrNull(cacheableSqmInterpretation, "jdbcSelect"); if (jdbcSelect != null) { return jdbcSelect.getSql(); } } } } return ReflectionUtils.invokeMethod(query, "getQueryString"); }
@Test public void testCriteriaAPI() { doInJPA(entityManager -> { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaQuery<PostComment> criteria = builder.createQuery(PostComment.class); Root<PostComment> postComment = criteria.from(PostComment.class); Join<PostComment, Post> post = postComment.join("post"); criteria.where( builder.like(post.get("title"), "%Java%") ); criteria.orderBy( builder.asc(postComment.get("id")) ); Query criteriaQuery = entityManager.createQuery(criteria); String sql = SQLExtractor.from(criteriaQuery); assertNotNull(sql); LOGGER.info( "The Criteria API query: [\n{}\n]\ngenerates the following SQL query: [\n{}\n]", criteriaQuery.unwrap(org.hibernate.query.Query.class).getQueryString(), sql ); }); }
public void parse(InputStream stream, ContentHandler handler, Metadata metadata, ParseContext context) throws IOException, SAXException, TikaException { metadata.set(Metadata.CONTENT_TYPE, "application/rtf"); TaggedInputStream tagged = new TaggedInputStream(stream); try { XHTMLContentHandler xhtmlHandler = new XHTMLContentHandler(handler, metadata); RTFEmbObjHandler embObjHandler = new RTFEmbObjHandler(xhtmlHandler, metadata, context, getMemoryLimitInKb()); final TextExtractor ert = new TextExtractor(xhtmlHandler, metadata, embObjHandler); ert.setIgnoreListMarkup(ignoreListMarkup); ert.extract(stream); } catch (IOException e) { tagged.throwIfCauseOf(e); throw new TikaException("Error parsing an RTF document", e); } }
@Test public void testEmbeddedLinkedDocument() throws Exception { Set<MediaType> skipTypes = new HashSet<>(); skipTypes.add(MediaType.parse("image/emf")); skipTypes.add(MediaType.parse("image/wmf")); TrackingHandler tracker = new TrackingHandler(skipTypes); try (TikaInputStream tis = TikaInputStream .get(getResourceAsStream("/test-documents/testRTFEmbeddedLink.rtf"))) { ContainerExtractor ex = new ParserContainerExtractor(); assertEquals(true, ex.isSupported(tis)); ex.extract(tis, ex, tracker); } //should gracefully skip link and not throw NPE, IOEx, etc assertEquals(0, tracker.filenames.size()); tracker = new TrackingHandler(); try (TikaInputStream tis = TikaInputStream .get(getResourceAsStream("/test-documents/testRTFEmbeddedLink.rtf"))) { ContainerExtractor ex = new ParserContainerExtractor(); assertEquals(true, ex.isSupported(tis)); ex.extract(tis, ex, tracker); } //should gracefully skip link and not throw NPE, IOEx, etc assertEquals(2, tracker.filenames.size()); }
public static ILogger noLogger() { return new NoLogFactory.NoLogger(); }
@Test public void noLogger() { assertInstanceOf(NoLogFactory.NoLogger.class, Logger.noLogger()); }
public int max() { return size > 0 ? data[size - 1] : 0; }
@Test public void max() { SortedIntList l = new SortedIntList(5); assertEquals(0, l.max()); l.add(1); assertEquals(1, l.max()); l.add(5); assertEquals(5, l.max()); l.add(10); assertEquals(10, l.max()); }
@Override public ProviderInfo doSelect(SofaRequest invocation, List<ProviderInfo> providerInfos) { String localhost = SystemInfo.getLocalHost(); if (StringUtils.isEmpty(localhost)) { return super.doSelect(invocation, providerInfos); } List<ProviderInfo> localProviderInfo = new ArrayList<ProviderInfo>(); for (ProviderInfo providerInfo : providerInfos) { // 解析IP,看是否和本地一致 if (localhost.equals(providerInfo.getHost())) { localProviderInfo.add(providerInfo); } } if (CommonUtils.isNotEmpty(localProviderInfo)) { // 命中本机的服务端 return super.doSelect(invocation, localProviderInfo); } else { // 没有命中本机上的服务端 return super.doSelect(invocation, providerInfos); } }
@Test public void doSelect() throws Exception { LocalPreferenceLoadBalancer loadBalancer = new LocalPreferenceLoadBalancer(null); Map<Integer, Integer> cnt = new HashMap<Integer, Integer>(); int size = 20; int total = 100000; SofaRequest request = new SofaRequest(); { for (int i = 0; i < size; i++) { cnt.put(9000 + i, 0); } List<ProviderInfo> providers = buildSameWeightProviderList(size); int localps = 5; for (int i = 0; i < localps; i++) { ProviderInfo localProvider = new ProviderInfo(); localProvider.setHost(SystemInfo.getLocalHost()); localProvider.setPort(22000 + i); providers.add(localProvider); cnt.put(22000 + i, 0); } long start = System.currentTimeMillis(); for (int i = 0; i < total; i++) { ProviderInfo provider = loadBalancer.doSelect(request, providers); int port = provider.getPort(); cnt.put(port, cnt.get(port) + 1); } long end = System.currentTimeMillis(); LOGGER.info("elapsed" + (end - start) + "ms"); LOGGER.info("avg " + (end - start) * 1000 * 1000 / total + "ns"); for (int i = 0; i < size; i++) { Assert.assertTrue(cnt.get(9000 + i) == 0); } int avg = total / localps; for (int i = 0; i < localps; i++) { Assert.assertTrue(avg * 0.9 < cnt.get(22000 + i) && avg * 1.1 > cnt.get(22000 + i)); // 随机偏差不会太大,应该不超过10% } } { for (int i = 0; i < size; i++) { cnt.put(9000 + i, 0); } List<ProviderInfo> providers = buildDiffWeightProviderList(size); int localps = 5; for (int i = 0; i < localps; i++) { ProviderInfo localProvider = new ProviderInfo(); localProvider.setHost(SystemInfo.getLocalHost()); localProvider.setPort(22000 + i); localProvider.setWeight(i * 100); providers.add(localProvider); cnt.put(22000 + i, 0); } long start = System.currentTimeMillis(); for (int i = 0; i < total; i++) { ProviderInfo provider = loadBalancer.doSelect(request, providers); int port = provider.getPort(); cnt.put(port, cnt.get(port) + 1); } long end = System.currentTimeMillis(); LOGGER.info("elapsed" + (end - start) + "ms"); LOGGER.info("avg " + (end - start) * 1000 * 1000 / total + "ns"); for (int i = 0; i < size; i++) { Assert.assertTrue(cnt.get(9000 + i) == 0); } int count = 0; for (int i = 0; i < localps; i++) { count += i; } int per = total / count; Assert.assertTrue(cnt.get(22000) == 0); for (int i = 1; i < localps; i++) { Assert.assertTrue(per * i * 0.9 < cnt.get(22000 + i) && per * i * 1.1 > cnt.get(22000 + i)); // 随机偏差不会太大,应该不超过10% } } }
public static String getKey(String dataId, String group) { StringBuilder sb = new StringBuilder(); GroupKey.urlEncode(dataId, sb); sb.append('+'); GroupKey.urlEncode(group, sb); return sb.toString(); }
@Test public void getKeyTenantIdentifyTest() { String key = Md5ConfigUtil.getKey("DataId", "Group", "Tenant", "Identify"); Assert.isTrue(Objects.equals("DataId+Group+Tenant+Identify", key)); }
public static void displayWelcomeMessage( final int consoleWidth, final PrintWriter writer ) { final String[] lines = { "", "===========================================", "= _ _ ____ ____ =", "= | | _____ __ _| | _ \\| __ ) =", "= | |/ / __|/ _` | | | | | _ \\ =", "= | <\\__ \\ (_| | | |_| | |_) | =", "= |_|\\_\\___/\\__, |_|____/|____/ =", "= |_| =", "= The Database purpose-built =", "= for stream processing apps =", "===========================================" }; final String copyrightMsg = "Copyright 2017-2022 Confluent Inc."; final Integer logoWidth = Arrays.stream(lines) .map(String::length) .reduce(0, Math::max); // Don't want to display the logo if it'll just end up getting wrapped and looking hideous if (consoleWidth < logoWidth) { writer.println("ksqlDB, " + copyrightMsg); } else { final int paddingChars = (consoleWidth - logoWidth) / 2; final String leftPadding = IntStream.range(0, paddingChars) .mapToObj(idx -> " ") .collect(Collectors.joining()); Arrays.stream(lines) .forEach(line -> writer.println(leftPadding + line)); writer.println(); writer.println(copyrightMsg); } writer.println(); writer.flush(); }
@Test public void shouldOutputShortWelcomeMessageIfConsoleNotWideEnough() { // When: WelcomeMsgUtils.displayWelcomeMessage(35, realPrintWriter); // Then: assertThat(stringWriter.toString(), is("ksqlDB, Copyright 2017-2022 Confluent Inc.\n\n")); }
@Path("/.well-known/openid-federation") @GET @Produces(MEDIA_TYPE_ENTITY_STATEMENT) public Response get() { var federationEntityJwks = federationConfig.entitySigningKeys().toPublicJWKSet(); var relyingPartyJwks = federationConfig.relyingPartyKeys().toPublicJWKSet(); var now = Instant.now(); var exp = now.plus(federationConfig.ttl()); var jws = EntityStatement.create() .iat(now) .nbf(now) .exp(exp) .iss(federationConfig.iss().toString()) .sub(federationConfig.sub().toString()) .authorityHints(List.of(federationConfig.federationMaster().toString())) .metadata( Metadata.create() .openIdRelyingParty( OpenIdRelyingParty.create() .clientName(federationConfig.appName()) .jwks(relyingPartyJwks) .responseTypes(List.of("code")) .grantTypes(List.of("authorization_code")) .requirePushedAuthorizationRequests(true) .idTokenSignedResponseAlg("ES256") .idTokenEncryptedResponseAlg("ECDH-ES") .idTokenEncryptedResponseEnc("A256GCM") .scope(String.join(" ", federationConfig.scopes())) .redirectUris(federationConfig.redirectUris()) .clientRegistrationTypes(List.of("automatic")) .tokenEndpointAuthMethodsSupported( List.of("self_signed_tls_client_auth")) // according to the federation spec this is not required here, some // sectoral IdPs require it though .defaultAcrValues(List.of("gematik-ehealth-loa-high")) // warn: this is a non-standard field, but needed by some sectoral IdPs .tokenEndpointAuthMethod("self_signed_tls_client_auth") .build()) .federationEntity( FederationEntity.create().name(federationConfig.appName()).build()) .build()) .jwks(federationEntityJwks) .build() .sign(federationConfig.entitySigningKey()); return Response.ok(jws.serialize()) .header("x-kc-provider", "ovi") .cacheControl(cacheForTtl(now)) .build(); }
@Test void get() { var res = given() .baseUri(server.configuration().baseUri().toString()) .get("/.well-known/openid-federation") .getBody(); var body = res.asString(); var es = EntityStatementJWS.parse(body); assertEquals(ISSUER.toString(), es.body().sub()); assertEquals(ISSUER.toString(), es.body().iss()); assertEquals(FEDMASTER.toString(), es.body().authorityHints().get(0)); }
public List<ErasureCodingPolicy> loadPolicy(String policyFilePath) { try { File policyFile = getPolicyFile(policyFilePath); if (!policyFile.exists()) { LOG.warn("Not found any EC policy file"); return Collections.emptyList(); } return loadECPolicies(policyFile); } catch (ParserConfigurationException | IOException | SAXException e) { throw new RuntimeException("Failed to load EC policy file: " + policyFilePath); } }
@Test public void testBadECCellsize() throws Exception { PrintWriter out = new PrintWriter(new FileWriter(POLICY_FILE)); out.println("<?xml version=\"1.0\"?>"); out.println("<configuration>"); out.println("<layoutversion>1</layoutversion>"); out.println("<schemas>"); out.println(" <schema id=\"RSk12m4\">"); out.println(" <codec>RS</codec>"); out.println(" <k>12</k>"); out.println(" <m>4</m>"); out.println(" </schema>"); out.println(" <schema id=\"RS-legacyk12m4\">"); out.println(" <codec>RS-legacy</codec>"); out.println(" <k>12</k>"); out.println(" <m>4</m>"); out.println(" </schema>"); out.println("</schemas>"); out.println("<policies>"); out.println(" <policy>"); out.println(" <schema>RSk12m4</schema>"); out.println(" <cellsize>free</cellsize>"); out.println(" </policy>"); out.println("</policies>"); out.println("</configuration>"); out.close(); ECPolicyLoader ecPolicyLoader = new ECPolicyLoader(); try { ecPolicyLoader.loadPolicy(POLICY_FILE); fail("IllegalArgumentException should be thrown for bad policy"); } catch (IllegalArgumentException e) { assertExceptionContains("Bad EC policy cellsize value free is found." + " It should be an integer", e); } }
public void logExecution(Execution execution, Logger logger, Level level, String message, Object... args) { String finalMsg = tenantEnabled ? EXECUTION_PREFIX_WITH_TENANT + message : EXECUTION_PREFIX_NO_TENANT + message; Object[] executionArgs = tenantEnabled ? new Object[] { execution.getTenantId(), execution.getNamespace(), execution.getFlowId(), execution.getId() } : new Object[] { execution.getNamespace(), execution.getFlowId(), execution.getId() }; Object[] finalArgs = ArrayUtils.addAll(executionArgs, args); logger.atLevel(level).log(finalMsg, finalArgs); }
@Test void logExecution() { var execution = Execution.builder().namespace("namespace").flowId("flow").id("execution").build(); logService.logExecution(execution, log, Level.INFO, "Some log"); logService.logExecution(execution, log, Level.INFO, "Some log with an {}", "attribute"); }
@Override public void invoke() throws Exception { // -------------------------------------------------------------------- // Initialize // -------------------------------------------------------------------- LOG.debug(getLogString("Start registering input and output")); // initialize OutputFormat initOutputFormat(); // initialize input readers try { initInputReaders(); } catch (Exception e) { throw new RuntimeException( "Initializing the input streams failed" + (e.getMessage() == null ? "." : ": " + e.getMessage()), e); } LOG.debug(getLogString("Finished registering input and output")); // -------------------------------------------------------------------- // Invoke // -------------------------------------------------------------------- LOG.debug(getLogString("Starting data sink operator")); RuntimeContext ctx = createRuntimeContext(); final Counter numRecordsIn; { Counter tmpNumRecordsIn; try { InternalOperatorIOMetricGroup ioMetricGroup = ((InternalOperatorMetricGroup) ctx.getMetricGroup()).getIOMetricGroup(); ioMetricGroup.reuseInputMetricsForTask(); ioMetricGroup.reuseOutputMetricsForTask(); tmpNumRecordsIn = ioMetricGroup.getNumRecordsInCounter(); } catch (Exception e) { LOG.warn("An exception occurred during the metrics setup.", e); tmpNumRecordsIn = new SimpleCounter(); } numRecordsIn = tmpNumRecordsIn; } if (RichOutputFormat.class.isAssignableFrom(this.format.getClass())) { ((RichOutputFormat) this.format).setRuntimeContext(ctx); LOG.debug(getLogString("Rich Sink detected. Initializing runtime context.")); } ExecutionConfig executionConfig = getExecutionConfig(); boolean objectReuseEnabled = executionConfig.isObjectReuseEnabled(); try { // initialize local strategies MutableObjectIterator<IT> input1; switch (this.config.getInputLocalStrategy(0)) { case NONE: // nothing to do localStrategy = null; input1 = reader; break; case SORT: // initialize sort local strategy try { // get type comparator TypeComparatorFactory<IT> compFact = this.config.getInputComparator(0, getUserCodeClassLoader()); if (compFact == null) { throw new Exception( "Missing comparator factory for local strategy on input " + 0); } // initialize sorter Sorter<IT> sorter = ExternalSorter.newBuilder( getEnvironment().getMemoryManager(), this, this.inputTypeSerializerFactory.getSerializer(), compFact.createComparator()) .maxNumFileHandles(this.config.getFilehandlesInput(0)) .enableSpilling( getEnvironment().getIOManager(), this.config.getSpillingThresholdInput(0)) .memoryFraction(this.config.getRelativeMemoryInput(0)) .objectReuse( this.getExecutionConfig().isObjectReuseEnabled()) .largeRecords(this.config.getUseLargeRecordHandler()) .build(this.reader); this.localStrategy = sorter; input1 = sorter.getIterator(); } catch (Exception e) { throw new RuntimeException( "Initializing the input processing failed" + (e.getMessage() == null ? "." : ": " + e.getMessage()), e); } break; default: throw new RuntimeException("Invalid local strategy for DataSinkTask"); } // read the reader and write it to the output final TypeSerializer<IT> serializer = this.inputTypeSerializerFactory.getSerializer(); final MutableObjectIterator<IT> input = input1; final OutputFormat<IT> format = this.format; // check if task has been canceled if (this.taskCanceled) { return; } LOG.debug(getLogString("Starting to produce output")); // open format.open( new InitializationContext() { @Override public int getNumTasks() { return getEnvironment().getTaskInfo().getNumberOfParallelSubtasks(); } @Override public int getTaskNumber() { return getEnvironment().getTaskInfo().getIndexOfThisSubtask(); } @Override public int getAttemptNumber() { return getEnvironment().getTaskInfo().getAttemptNumber(); } }); if (objectReuseEnabled) { IT record = serializer.createInstance(); // work! while (!this.taskCanceled && ((record = input.next(record)) != null)) { numRecordsIn.inc(); format.writeRecord(record); } } else { IT record; // work! while (!this.taskCanceled && ((record = input.next()) != null)) { numRecordsIn.inc(); format.writeRecord(record); } } // close. We close here such that a regular close throwing an exception marks a task as // failed. if (!this.taskCanceled) { this.format.close(); this.format = null; } } catch (Exception ex) { // make a best effort to clean up try { if (!cleanupCalled && format instanceof CleanupWhenUnsuccessful) { cleanupCalled = true; ((CleanupWhenUnsuccessful) format).tryCleanupOnError(); } } catch (Throwable t) { LOG.error("Cleanup on error failed.", t); } ex = ExceptionInChainedStubException.exceptionUnwrap(ex); if (ex instanceof CancelTaskException) { // forward canceling exception throw ex; } // drop, if the task was canceled else if (!this.taskCanceled) { if (LOG.isErrorEnabled()) { LOG.error(getLogString("Error in user code: " + ex.getMessage()), ex); } throw ex; } } finally { if (this.format != null) { // close format, if it has not been closed, yet. // This should only be the case if we had a previous error, or were canceled. try { this.format.close(); } catch (Throwable t) { if (LOG.isWarnEnabled()) { LOG.warn(getLogString("Error closing the output format"), t); } } } // close local strategy if necessary if (localStrategy != null) { try { this.localStrategy.close(); } catch (Throwable t) { LOG.error("Error closing local strategy", t); } } BatchTask.clearReaders(new MutableReader<?>[] {inputReader}); } if (!this.taskCanceled) { LOG.debug(getLogString("Finished data sink operator")); } else { LOG.debug(getLogString("Data sink operator cancelled")); } }
@Test @SuppressWarnings("unchecked") void testSortingDataSinkTask() { int keyCnt = 100; int valCnt = 20; double memoryFraction = 1.0; super.initEnvironment(MEMORY_MANAGER_SIZE, NETWORK_BUFFER_SIZE); super.addInput(new UniformRecordGenerator(keyCnt, valCnt, true), 0); DataSinkTask<Record> testTask = new DataSinkTask<>(this.mockEnv); // set sorting super.getTaskConfig().setInputLocalStrategy(0, LocalStrategy.SORT); super.getTaskConfig() .setInputComparator( new RecordComparatorFactory(new int[] {1}, (new Class[] {IntValue.class})), 0); super.getTaskConfig().setRelativeMemoryInput(0, memoryFraction); super.getTaskConfig().setFilehandlesInput(0, 8); super.getTaskConfig().setSpillingThresholdInput(0, 0.8f); File tempTestFile = new File(tempFolder.toFile(), UUID.randomUUID().toString()); super.registerFileOutputTask( MockOutputFormat.class, tempTestFile.toURI().toString(), new Configuration()); try { testTask.invoke(); } catch (Exception e) { LOG.debug("Exception while invoking the test task.", e); fail("Invoke method caused exception."); } assertThat(tempTestFile).withFailMessage("Temp output file does not exist").exists(); FileReader fr = null; BufferedReader br = null; try { fr = new FileReader(tempTestFile); br = new BufferedReader(fr); Set<Integer> keys = new HashSet<>(); int curVal = -1; while (br.ready()) { String line = br.readLine(); Integer key = Integer.parseInt(line.substring(0, line.indexOf("_"))); Integer val = Integer.parseInt(line.substring(line.indexOf("_") + 1, line.length())); // check that values are in correct order assertThat(val) .withFailMessage("Values not in ascending order") .isGreaterThanOrEqualTo(curVal); // next value hit if (val > curVal) { if (curVal != -1) { // check that we saw 100 distinct keys for this values assertThat(keys).withFailMessage("Keys missing for value").hasSize(100); } // empty keys set keys.clear(); // update current value curVal = val; } assertThat(keys.add(key)).withFailMessage("Duplicate key for value").isTrue(); } } catch (FileNotFoundException e) { fail("Out file got lost..."); } catch (IOException ioe) { fail("Caught IOE while reading out file"); } finally { if (br != null) { try { br.close(); } catch (Throwable t) { } } if (fr != null) { try { fr.close(); } catch (Throwable t) { } } } }
@Override public Object getInitialAggregatedValue(Object rawValue) { CpcUnion cpcUnion = new CpcUnion(_lgK); if (rawValue instanceof byte[]) { // Serialized Sketch byte[] bytes = (byte[]) rawValue; cpcUnion.update(deserializeAggregatedValue(bytes)); } else if (rawValue instanceof byte[][]) { // Multiple Serialized Sketches byte[][] serializedSketches = (byte[][]) rawValue; for (byte[] bytes : serializedSketches) { cpcUnion.update(deserializeAggregatedValue(bytes)); } } else { CpcSketch pristineSketch = empty(); addObjectToSketch(rawValue, pristineSketch); cpcUnion.update(pristineSketch); } return cpcUnion; }
@Test public void getInitialValueShouldSupportMultiValueTypes() { DistinctCountCPCSketchValueAggregator agg = new DistinctCountCPCSketchValueAggregator(Collections.emptyList()); Integer[] ints = {12345}; assertEquals(toSketch(agg.getInitialAggregatedValue(ints)).getEstimate(), 1.0); Long[] longs = {12345L}; assertEquals(toSketch(agg.getInitialAggregatedValue(longs)).getEstimate(), 1.0); Float[] floats = {12.345f}; assertEquals(toSketch(agg.getInitialAggregatedValue(floats)).getEstimate(), 1.0); Double[] doubles = {12.345d}; assertEquals(toSketch(agg.getInitialAggregatedValue(doubles)).getEstimate(), 1.0); Object[] objects = {new Object()}; assertThrows(() -> agg.getInitialAggregatedValue(objects)); byte[][] zeroSketches = {}; assertEquals(toSketch(agg.getInitialAggregatedValue(zeroSketches)).getEstimate(), 0.0); }