下面列出了org.apache.hadoop.fs.UnresolvedLinkException#org.apache.commons.io.Charsets 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Test
public void testFileUploadWithEagerParsingAndNonASCIIFilename() throws Exception {
DefaultServer.setRootHandler(new EagerFormParsingHandler().setNext(createHandler()));
TestHttpClient client = new TestHttpClient();
try {
HttpPost post = new HttpPost(DefaultServer.getDefaultServerURL() + "/path");
MultipartEntity entity = new MultipartEntity();
entity.addPart("formValue", new StringBody("myValue", "text/plain", StandardCharsets.UTF_8));
File uploadfile = new File(MultipartFormDataParserTestCase.class.getResource("uploadfile.txt").getFile());
FormBodyPart filePart = new FormBodyPart("file", new FileBody(uploadfile, "τεστ", "application/octet-stream", Charsets.UTF_8.toString()));
filePart.addField("Content-Disposition", "form-data; name=\"file\"; filename*=\"utf-8''%CF%84%CE%B5%CF%83%CF%84.txt\"");
entity.addPart(filePart);
post.setEntity(entity);
HttpResponse result = client.execute(post);
Assert.assertEquals(StatusCodes.OK, result.getStatusLine().getStatusCode());
HttpClientUtils.readResponse(result);
} finally {
client.getConnectionManager().shutdown();
}
}
/**
* Reads a JSON manifest file into a JSON manifest object.
*
* @param jsonManifestFile the JSON manifest file.
*
* @return the manifest object.
* @throws java.io.IOException if any errors were encountered reading the JSON file.
* @throws IllegalArgumentException if the manifest file has validation errors.
*/
public M readJsonManifest(File jsonManifestFile) throws IOException, IllegalArgumentException
{
// Verify that the file exists and can be read.
HerdFileUtils.verifyFileExistsAndReadable(jsonManifestFile);
// Deserialize the JSON manifest.
BufferedInputStream buffer = new BufferedInputStream(new FileInputStream(jsonManifestFile));
BufferedReader reader = new BufferedReader(new InputStreamReader(buffer, Charsets.UTF_8));
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
objectMapper.setVisibility(PropertyAccessor.GETTER, Visibility.NONE);
objectMapper.setVisibility(PropertyAccessor.SETTER, Visibility.NONE);
M manifest = getManifestFromReader(reader, objectMapper);
// Validate the manifest and return it.
validateManifest(manifest);
return manifest;
}
@Test
public void testUploadReject() throws Exception {
HttpURLConnection urlConn = request("/test/v1/uploadReject", HttpMethod.POST, true);
try {
urlConn.setChunkedStreamingMode(1024);
urlConn.getOutputStream().write("Rejected Content".getBytes(Charsets.UTF_8));
try {
urlConn.getInputStream();
fail();
} catch (IOException e) {
// Expect to get exception since server response with 400. Just drain the error stream.
IOUtils.toByteArray(urlConn.getErrorStream());
assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), urlConn.getResponseCode());
}
} finally {
urlConn.disconnect();
}
}
public XmlRecordReader(FileSplit split, Configuration conf) throws IOException {
endTag = ENDING_TAG.getBytes(Charsets.UTF_8);
startTag = STARTING_TAG.getBytes(Charsets.UTF_8);
// open the file and seek to the start of the split
start = split.getStart();
// set the end of the file
end = start + split.getLength();
Path file = split.getPath();
FileSystem fs = file.getFileSystem(conf);
FileStatus fStatus = fs.getFileStatus(file);
blocks = fs.getFileBlockLocations(fStatus, 0, fStatus.getLen());
// seek the start of file
fsin = fs.open(split.getPath());
fsin.seek(start);
}
private void processQueue(ProcessSession session) {
String xml;
while ((xml = renderedXMLs.peek()) != null) {
FlowFile flowFile = session.create();
byte[] xmlBytes = xml.getBytes(Charsets.UTF_8);
flowFile = session.write(flowFile, out -> out.write(xmlBytes));
flowFile = session.putAttribute(flowFile, CoreAttributes.MIME_TYPE.key(), APPLICATION_XML);
session.getProvenanceReporter().receive(flowFile, provenanceUri);
session.transfer(flowFile, REL_SUCCESS);
session.commit();
if (!renderedXMLs.remove(xml) && getLogger().isWarnEnabled()) {
getLogger().warn(new StringBuilder("Event ")
.append(xml)
.append(" had already been removed from queue, FlowFile ")
.append(flowFile.getAttribute(CoreAttributes.UUID.key()))
.append(" possible duplication of data")
.toString());
}
}
}
public static List<WinNT.HANDLE> mockEventHandles(WEvtApi wEvtApi, Kernel32 kernel32, List<String> eventXmls) {
List<WinNT.HANDLE> eventHandles = new ArrayList<>();
for (String eventXml : eventXmls) {
WinNT.HANDLE eventHandle = mock(WinNT.HANDLE.class);
when(wEvtApi.EvtRender(isNull(WinNT.HANDLE.class), eq(eventHandle), eq(WEvtApi.EvtRenderFlags.EVENT_XML),
anyInt(), any(Pointer.class), any(Pointer.class), any(Pointer.class))).thenAnswer(invocation -> {
Object[] arguments = invocation.getArguments();
Pointer bufferUsed = (Pointer) arguments[5];
byte[] array = Charsets.UTF_16LE.encode(eventXml).array();
if (array.length > (int) arguments[3]) {
when(kernel32.GetLastError()).thenReturn(W32Errors.ERROR_INSUFFICIENT_BUFFER).thenReturn(W32Errors.ERROR_SUCCESS);
} else {
((Pointer) arguments[4]).write(0, array, 0, array.length);
}
bufferUsed.setInt(0, array.length);
return false;
});
eventHandles.add(eventHandle);
}
return eventHandles;
}
/**
* Test option with option length > 128.
*/
@Test
public void longOptionTest() throws Exception {
byte[] data = Resources.toByteArray(Dhcp6RelayTest.class.getResource(LONG_OPT));
DHCP dhcp = DHCP.deserializer().deserialize(data, 0, data.length);
assertEquals(2, dhcp.getOptions().size());
DhcpOption hostnameOption = dhcp.getOption(DHCP.DHCPOptionCode.OptionCode_HostName);
DhcpOption endOption = dhcp.getOption(DHCP.DHCPOptionCode.OptionCode_END);
assertNotNull(hostnameOption);
assertNotNull(endOption);
// Host name contains 200 "A"
StringBuilder hostnameBuilder = new StringBuilder();
IntStream.range(0, 200).forEach(i -> hostnameBuilder.append("A"));
String hostname = hostnameBuilder.toString();
assertEquals((byte) 200, hostnameOption.getLength());
assertArrayEquals(hostname.getBytes(Charsets.US_ASCII), hostnameOption.getData());
}
@Test
public void getList() throws IOException {
String expected = "v1.0.0\nv1.0.1";
String name = "module/@v/v1.0.0.list";
NestedAttributesMap attributesMap = mock(NestedAttributesMap.class);
when(attributesMap.get("asset_kind")).thenReturn(PACKAGE.name());
when(asset1.name()).thenReturn("modulename/@v/v1.0.0.zip");
when(asset1.formatAttributes()).thenReturn(attributesMap);
when(asset2.name()).thenReturn("modulename/@v/v1.0.1.zip");
when(asset2.formatAttributes()).thenReturn(attributesMap);
when(dataAccess.findAssetsForModule(tx, repository, name)).thenReturn(
ImmutableList.of(asset1, asset2)
);
Content content = underTest.getList(name);
String response = CharStreams.toString(new InputStreamReader(content.openInputStream(), Charsets.UTF_8));
assertThat(response, is(equalTo(expected)));
}
public static List<HyperParameterScopeItem> read(final String configFilePath) {
final File file = new File(configFilePath);
List<String> lines;
try {
lines = FileUtils.readLines(file, Charsets.UTF_8);
} catch (final IOException e) {
throw new IllegalStateException(e);
}
final List<HyperParameterScopeItem> result = Lists.newArrayList();
for (final String line : lines) {
final String[] segments = StringUtils.split(line, ',');
final List<String> values = Lists.newArrayList();
for (int i = 1; i < segments.length; ++i) {
values.add(segments[i]);
}
final HyperParameterScopeItem item = new HyperParameterScopeItem(segments[0], values);
result.add(item);
}
return result;
}
/**
* Returns a map of Query Parameter Name to Values
*
* @param context ProcessContext
* @return Map of names and values
*/
protected Map<String, List<String>> getParameters(ProcessContext context) {
if (!context.getProperty(PROP_QUERY_PARAMS).isSet()) {
return new HashMap<>();
}
final String queryString = context.getProperty(PROP_QUERY_PARAMS)
.evaluateAttributeExpressions().getValue();
List<NameValuePair> params = URLEncodedUtils
.parse(queryString, Charsets.toCharset("UTF-8"));
if (params.isEmpty()) {
return new HashMap<>();
}
Map<String, List<String>> map = new HashMap<>();
for (NameValuePair nvp : params) {
if (!map.containsKey(nvp.getName())) {
map.put(nvp.getName(), new ArrayList<>());
}
map.get(nvp.getName()).add(nvp.getValue());
}
return map;
}
/**
* For a given absolute path, create all ancestors as directories along the
* path. All ancestors inherit their parent's permission plus an implicit
* u+wx permission. This is used by create() and addSymlink() for
* implicitly creating all directories along the path.
*
* For example, path="/foo/bar/spam", "/foo" is an existing directory,
* "/foo/bar" is not existing yet, the function will create directory bar.
*
* @return a tuple which contains both the new INodesInPath (with all the
* existing and newly created directories) and the last component in the
* relative path. Or return null if there are errors.
*/
static Map.Entry<INodesInPath, String> createAncestorDirectories(
FSDirectory fsd, INodesInPath iip, PermissionStatus permission)
throws IOException {
final String last = new String(iip.getLastLocalName(), Charsets.UTF_8);
INodesInPath existing = iip.getExistingINodes();
List<String> children = iip.getPath(existing.length(),
iip.length() - existing.length());
int size = children.size();
if (size > 1) { // otherwise all ancestors have been created
List<String> directories = children.subList(0, size - 1);
INode parentINode = existing.getLastINode();
// Ensure that the user can traversal the path by adding implicit
// u+wx permission to all ancestor directories
existing = createChildrenDirectories(fsd, existing, directories,
addImplicitUwx(parentINode.getPermissionStatus(), permission));
if (existing == null) {
return null;
}
}
return new AbstractMap.SimpleImmutableEntry<>(existing, last);
}
@Test
public void getInfo() throws IOException {
DateTime blobCreated = DateTime.now();
String expected = String.format("{\"Version\":\"v1.0.0\",\"Time\":\"%s\"}", blobCreated.toString());
when(dataAccess.findAsset(any(), any(), any())).thenReturn(asset1);
when(asset1.blobCreated()).thenReturn(blobCreated);
GolangAttributes goAttributes = new GolangAttributes();
goAttributes.setModule("module");
goAttributes.setVersion("v1.0.0");
Content content = underTest.getInfo(MODULE_INFO, goAttributes);
String response = CharStreams.toString(new InputStreamReader(content.openInputStream(), Charsets.UTF_8));
assertThat(response, is(equalTo(expected)));
}
private static FSNamesystem setupFileSystem() throws IOException {
Configuration conf = new Configuration();
conf.setLong(DFS_NAMENODE_ACCESSTIME_PRECISION_KEY, 1L);
FSEditLog editlog = mock(FSEditLog.class);
FSImage image = mock(FSImage.class);
when(image.getEditLog()).thenReturn(editlog);
final FSNamesystem fsn = new FSNamesystem(conf, image, true);
final FSDirectory fsd = fsn.getFSDirectory();
INodesInPath iip = fsd.getINodesInPath("/", true);
PermissionStatus perm = new PermissionStatus(
"hdfs", "supergroup",
FsPermission.createImmutable((short) 0x1ff));
final INodeFile file = new INodeFile(
MOCK_INODE_ID, FILE_NAME.getBytes(Charsets.UTF_8),
perm, 1, 1, new BlockInfoContiguous[] {}, (short) 1,
DFS_BLOCK_SIZE_DEFAULT);
fsn.getFSDirectory().addINode(iip, file);
return fsn;
}
/**
* For a given absolute path, create all ancestors as directories along the
* path. All ancestors inherit their parent's permission plus an implicit
* u+wx permission. This is used by create() and addSymlink() for
* implicitly creating all directories along the path.
*
* For example, path="/foo/bar/spam", "/foo" is an existing directory,
* "/foo/bar" is not existing yet, the function will create directory bar.
*
* @return a tuple which contains both the new INodesInPath (with all the
* existing and newly created directories) and the last component in the
* relative path. Or return null if there are errors.
*/
static Map.Entry<INodesInPath, String> createAncestorDirectories(
FSDirectory fsd, INodesInPath iip, PermissionStatus permission)
throws IOException {
final String last = new String(iip.getLastLocalName(), Charsets.UTF_8);
INodesInPath existing = iip.getExistingINodes();
List<String> children = iip.getPath(existing.length(),
iip.length() - existing.length());
int size = children.size();
if (size > 1) { // otherwise all ancestors have been created
List<String> directories = children.subList(0, size - 1);
INode parentINode = existing.getLastINode();
// Ensure that the user can traversal the path by adding implicit
// u+wx permission to all ancestor directories
existing = createChildrenDirectories(fsd, existing, directories,
addImplicitUwx(parentINode.getPermissionStatus(), permission));
if (existing == null) {
return null;
}
}
return new AbstractMap.SimpleImmutableEntry<>(existing, last);
}
public String tensorboardJinjaTemplateTest(Boolean dist, Boolean launchMode) throws IOException {
URL urlTemplate = Resources.getResource(SubmarineJob.SUBMARINE_TENSORBOARD_JINJA);
String template = Resources.toString(urlTemplate, Charsets.UTF_8);
Jinjava jinjava = new Jinjava();
HashMap<String, Object> jinjaParams = initJinjaParams(dist, launchMode);
String submarineCmd = jinjava.render(template, jinjaParams);
int pos = submarineCmd.indexOf("\n");
if (pos == 0) {
submarineCmd = submarineCmd.replaceFirst("\n", "");
}
LOGGER.info("------------------------");
LOGGER.info(submarineCmd);
LOGGER.info("------------------------");
return submarineCmd;
}
public String jobRunJinjaTemplateTest(Boolean dist, Boolean launchMode) throws IOException {
URL urlTemplate = Resources.getResource(SubmarineJob.SUBMARINE_JOBRUN_TF_JINJA);
String template = Resources.toString(urlTemplate, Charsets.UTF_8);
Jinjava jinjava = new Jinjava();
HashMap<String, Object> jinjaParams = initJinjaParams(dist, launchMode);
String submarineCmd = jinjava.render(template, jinjaParams);
int pos = submarineCmd.indexOf("\n");
if (pos == 0) {
submarineCmd = submarineCmd.replaceFirst("\n", "");
}
LOGGER.info("------------------------");
LOGGER.info(submarineCmd);
LOGGER.info("------------------------");
return submarineCmd;
}
@Test
public void executeAndGenResponseThrowsExceptionTest() {
// ResponseOnSingeReq (Channel channel) {
ResponseOnSingeRequest sshResponse = new ResponseOnSingeRequest();
ChannelExec channel = mock(ChannelExec.class);
sshProvider = new SshProvider(sshMetaKey, hostIpSample);
String stdoutStr = "Mon Sep 14 21:52:27 UTC 2015";
InputStream in = new ByteArrayInputStream(
stdoutStr.getBytes(Charsets.UTF_8));
try {
when(channel.getInputStream()).thenReturn(in);
when(channel.isClosed()).thenReturn(false).thenThrow(
new RuntimeException("fake exception"));
sshResponse = sshProvider.executeAndGenResponse(channel);
} catch (Throwable e) {
logger.info("expected exception {}", "String", e);
}
logger.info(sshResponse.toString());
}
@Test
public void testDefaultModuleSpec() throws Exception {
URL rootPathUrl = getClass().getClassLoader().getResource(TEST_SCRIPTS_PATH.getResourcePath());
Path rootPath = Paths.get(rootPathUrl.toURI()).toAbsolutePath();
Set<String> singleFileScripts = TEST_SCRIPTS_PATH.getContentPaths();
for (String script: singleFileScripts) {
Path scriptPath = rootPath.resolve(script);
SingleFileScriptArchive scriptArchive = new SingleFileScriptArchive.Builder(scriptPath)
.build();
String moduleId = script.replaceAll("\\.", "_");
assertEquals(scriptArchive.getModuleSpec().getModuleId().toString(), moduleId);
Set<String> archiveEntryNames = scriptArchive.getArchiveEntryNames();
assertEquals(archiveEntryNames.size(), 1);
for (String entryName : archiveEntryNames) {
URL entryUrl = scriptArchive.getEntry(entryName);
assertNotNull(entryUrl);
InputStream inputStream = entryUrl.openStream();
String content = IOUtils.toString(inputStream, Charsets.UTF_8);
// We have stored the file name as the content of the file
assertEquals(content, script + "\n");
}
}
}
String extractPassword(String pwFile) {
if (pwFile.isEmpty()) {
// If there is no password file defined, we'll assume that we should do
// an anonymous bind
return "";
}
StringBuilder password = new StringBuilder();
try (Reader reader = new InputStreamReader(
new FileInputStream(pwFile), Charsets.UTF_8)) {
int c = reader.read();
while (c > -1) {
password.append((char)c);
c = reader.read();
}
return password.toString().trim();
} catch (IOException ioe) {
throw new RuntimeException("Could not read password file: " + pwFile, ioe);
}
}
private static MultiValueMap<String, String> convertQuery(String query) {
MultiValueMap<String, String> valueMap = new LinkedMultiValueMap<>();
if (!StringUtils.isEmpty(query)) {
if (query.startsWith("?")) query = query.substring(1);
StringTokenizer tokenizer = new StringTokenizer(query, "&");
while (tokenizer.hasMoreElements()) {
String element = tokenizer.nextToken();
int end = element.indexOf("=");
if (end > 0 && end < element.length() - 1) {
String key = element.substring(0, end);
String value = element.substring(end + 1);
valueMap.add(key, UrlCoder.urlDecode(value, Charsets.UTF_8));
}
}
}
return valueMap;
}
String extractPassword(String pwFile) {
if (pwFile.isEmpty()) {
// If there is no password file defined, we'll assume that we should do
// an anonymous bind
return "";
}
StringBuilder password = new StringBuilder();
try (Reader reader = new InputStreamReader(
new FileInputStream(pwFile), Charsets.UTF_8)) {
int c = reader.read();
while (c > -1) {
password.append((char)c);
c = reader.read();
}
return password.toString().trim();
} catch (IOException ioe) {
throw new RuntimeException("Could not read password file: " + pwFile, ioe);
}
}
/**
* Read a single byte from the stream.
*/
@Override
public int read() throws IOException {
if (pos < buffer.length) {
return buffer[pos++];
}
if (!fileReader.hasNext()) {
return -1;
}
writer.write(fileReader.next(), encoder);
encoder.flush();
if (!fileReader.hasNext()) {
// Write a new line after the last Avro record.
output.write(System.getProperty("line.separator")
.getBytes(Charsets.UTF_8));
output.flush();
}
pos = 0;
buffer = output.toByteArray();
output.reset();
return read();
}
/**
* Generates a random number using two UUIDs and HMAC-SHA1
*
* @return generated secure random number
* @throws IdentityOAuthAdminException Invalid Algorithm or Invalid Key
*/
public static String getRandomNumber() throws IdentityOAuthAdminException {
try {
String secretKey = UUIDGenerator.generateUUID();
String baseString = UUIDGenerator.generateUUID();
SecretKeySpec key = new SecretKeySpec(secretKey.getBytes(Charsets.UTF_8), ALGORITHM);
Mac mac = Mac.getInstance(ALGORITHM);
mac.init(key);
byte[] rawHmac = mac.doFinal(baseString.getBytes(Charsets.UTF_8));
String random = Base64.encode(rawHmac);
// Registry doesn't have support for these character.
random = random.replace("/", "_");
random = random.replace("=", "a");
random = random.replace("+", "f");
return random;
} catch (Exception e) {
throw new IdentityOAuthAdminException("Error when generating a random number.", e);
}
}
/**
* Puts a string into the buffer by first writing the size of the string
* as an int, followed by the bytes of the string, padded if necessary to
* a multiple of 4.
*/
protected void xdr_string(String s) {
byte[] bytes = s.getBytes(Charsets.UTF_8);
int len = bytes.length;
xdr_int(len);
System.arraycopy(bytes, 0, buffer, offset, len);
offset += len;
pad();
}
@Override
public void writeTo(JSONStreamAware jsonStreamAware, Class<?> aClass, Type type, Annotation[] annotations,
MediaType mediaType, MultivaluedMap<String, Object> stringObjectMultivaluedMap,
OutputStream outputStream) throws IOException, WebApplicationException {
Writer writer = new OutputStreamWriter(outputStream, Charsets.UTF_8);
jsonStreamAware.writeJSONString(writer);
writer.write(ENTER);
writer.flush();
}
private Pair<Integer, Integer> grabDefaultEngineTypes(String tempMetadataDir) throws IOException {
int engineType = -1;
int storageType = -1;
List<String> lines = FileUtils.readLines(new File(tempMetadataDir, "kylin.properties"), Charsets.UTF_8);
for (String l : lines) {
if (l.startsWith("kylin.engine.default")) {
engineType = Integer.parseInt(l.substring(l.lastIndexOf('=') + 1).trim());
}
if (l.startsWith("kylin.storage.default")) {
storageType = Integer.parseInt(l.substring(l.lastIndexOf('=') + 1).trim());
}
}
if (debug) {
logger.info("Grap from kylin.properties, engine type is {}", engineType);
logger.info("Grap from kylin.properties, storage type is {}", storageType);
}
String tmp = System.getProperty("kylin.engine");
if (!StringUtils.isBlank(tmp)) {
engineType = Integer.parseInt(tmp.trim());
if (debug) {
logger.info("By system property, engine type is {}", engineType);
}
}
tmp = System.getProperty("kylin.storage");
if (!StringUtils.isBlank(tmp)) {
storageType = Integer.parseInt(tmp.trim());
if (debug) {
logger.info("By system property, storage type is {}", storageType);
}
}
if (engineType < 0 || storageType < 0)
throw new IllegalStateException();
return Pair.newPair(engineType, storageType);
}
private Document generateToken(String requestTemplate, boolean sign, Credential headerCred, Credential hokCred, SAMLNameIdentifier nameIdentifier, String authmethod, List<SAMLAttribute> attributes, List<SAMLAttributeDesignator> designators, int validity) throws TechnicalConnectorException {
try {
String request = ConnectorXmlUtils.flatten(requestTemplate);
request = this.processDefaultFields(request, validity, nameIdentifier);
request = this.processHolderOfKeyCredentials(hokCred, request);
request = StringUtils.replace(request, "${authenticationMethod}", authmethod);
Element payload = ConnectorXmlUtils.toElement(request.getBytes(Charsets.UTF_8));
Document doc = payload.getOwnerDocument();
this.addDesignators(designators, doc);
this.processAttributes(attributes, doc);
boolean alwaysSign = Boolean.parseBoolean(ConfigFactory.getConfigValidator().getProperty("be.ehealth.technicalconnector.service.sts.always.sign.inner.request"));
if (sign && (!headerCred.getCertificate().equals(hokCred.getCertificate()) || alwaysSign)) {
try {
String keyinfoType = ConfigFactory.getConfigValidator().getProperty("be.ehealth.technicalconnector.service.sts.keyinfo", "x509");
if ("publickey".equalsIgnoreCase(keyinfoType)) {
this.signRequest(doc.getDocumentElement(), hokCred.getPrivateKey(), hokCred.getPublicKey());
} else {
this.signRequest(doc.getDocumentElement(), hokCred.getPrivateKey(), hokCred.getCertificate());
}
} catch (Exception var15) {
throw new TechnicalConnectorException(TechnicalConnectorExceptionValues.ERROR_SIGNATURE, new Object[]{"XML signature error: " + var15.getMessage(), var15});
}
}
return doc;
} catch (CertificateEncodingException var16) {
throw new TechnicalConnectorException(TechnicalConnectorExceptionValues.ERROR_CRYPTO, var16, new Object[]{var16.getMessage()});
}
}
/** Test utf-8 string cutting. */
@Test
public void testConvert() {
// 8 bytes total: 1b, 1b, 3b, 3b.
byte[] bytes = StringInlineIndexColumn.trimUTF8("00\u20ac\u20ac".getBytes(Charsets.UTF_8), 7);
assertEquals(5, bytes.length);
String s = new String(bytes);
assertEquals(3, s.length());
bytes = StringInlineIndexColumn.trimUTF8("aaaaaa".getBytes(Charsets.UTF_8), 4);
assertEquals(4, bytes.length);
}
public static String constructCommand(final WSManRequestInputs wsManRequestInputs, final PSEdition psEdition) {
final StringBuilder command = new StringBuilder()
.append(psEdition.getCmd())
.append(SPACE)
.append(NON_INTERACTIVE_PARAMETER)
.append(SPACE);
if(StringUtils.isNotBlank(wsManRequestInputs.getConfigurationName())) {
command.append(CONFIGURATION_NAME_PARAMETER)
.append(SPACE)
.append(wsManRequestInputs.getConfigurationName())
.append(SPACE);
}
command.append(ENCODED_COMMAND_PARAMETER)
.append(SPACE);
if (StringUtilities.isNotBlank(wsManRequestInputs.getModules())) {
command.append(EncoderDecoder.encodeStringInBase64(
IMPORT_MODULE_PARAMETER +
SPACE +
getEscapedModules(wsManRequestInputs) +
LF +
wsManRequestInputs.getScript(), Charsets.UTF_16LE));
} else {
command.append(EncoderDecoder.encodeStringInBase64(wsManRequestInputs.getScript(), Charsets.UTF_16LE));
}
return command.toString();
}
private static void validateVarCharValues(int blockWidth, VectorPivotDef def, FixedBlockVector block,
VariableBlockVector varBlock, String[] expected){
int[] expectNulls = new int[expected.length];
String[] expectValues = new String[expected.length];
for(int i =0; i < expected.length; i++){
String e = expected[i];
if(e != null){
expectNulls[i] = 1;
expectValues[i] = e;
}
}
int[] actualNulls = new int[expectNulls.length];
String[] actualValues = new String[expectNulls.length];
long nullBitOffsetA = def.getNullBitOffset();
final ArrowBuf buf = block.getUnderlying();
for(int i =0; i < expectNulls.length; i++){
actualNulls[i] = (buf.getInt(((i * blockWidth) + def.getNullByteOffset())) >>> nullBitOffsetA) & 1;
if (actualNulls[i] != 0) {
int offset = buf.getInt(i * blockWidth + blockWidth - 4);
int len = varBlock.getUnderlying().getInt(offset + 4);
byte val[] = new byte[len];
varBlock.getUnderlying().getBytes(offset + 4 + 4, val, 0, len);
actualValues[i] = new String(val, Charsets.UTF_8);
}
}
assertArrayEquals(expectNulls, actualNulls);
assertArrayEquals(expectValues, actualValues);
}