Example usage for org.apache.commons.io Charsets UTF_8

List of usage examples for org.apache.commons.io Charsets UTF_8

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.io.*
  5. Charsets
  6. UTF_8

Introduction

In this page you can find the example usage for org.apache.commons.io Charsets UTF_8.

Prototype

Charset UTF_8

To view the source code for org.apache.commons.io Charsets UTF_8.

Click Source Link

Document

Eight-bit Unicode Transformation Format.

Usage

From source file:com.github.chenxiaolong.dualbootpatcher.RomUtils.java

private static boolean usesLiveWallpaper(RomInformation info, MbtoolInterface iface)
        throws IOException, MbtoolException, MbtoolCommandException {
    String wallpaperInfoPath = info.getDataPath() + "/system/users/0/wallpaper_info.xml";

    int id = -1;//www .  ja  v  a  2s. c o m

    try {
        id = iface.fileOpen(wallpaperInfoPath, new short[] { FileOpenFlag.RDONLY }, 0);

        StatBuf sb = iface.fileStat(id);

        // Check file size
        if (sb.st_size < 0 || sb.st_size > 1024) {
            return false;
        }

        // Read file into memory
        byte[] data = new byte[(int) sb.st_size];
        int nWritten = 0;
        while (nWritten < data.length) {
            ByteBuffer newData = iface.fileRead(id, 10240);

            int nRead = newData.limit() - newData.position();
            newData.get(data, nWritten, nRead);
            nWritten += nRead;
        }

        iface.fileClose(id);
        id = -1;

        String xml = new String(data, Charsets.UTF_8);
        return xml.contains("component=");
    } finally {
        if (id >= 0) {
            try {
                iface.fileClose(id);
            } catch (IOException e) {
                // Ignore
            }
        }
    }
}

From source file:com.cloudbees.hudson.plugins.folder.computed.FolderComputation.java

@Nonnull
public AnnotatedLargeText<FolderComputation<I>> getEventsText() {
    File eventsFile = getEventsFile();
    if (eventsFile.length() <= 0) {
        ByteBuffer buffer = new ByteBuffer();
        try {//from   w w w. j  a  v  a 2  s .c  om
            buffer.write(String.format("No events as of %tc, waiting for events...%n", new Date())
                    .getBytes(Charsets.UTF_8));
            return new AnnotatedLargeText<FolderComputation<I>>(buffer, Charsets.UTF_8, false, this);
        } catch (IOException e) {
            // ignore and fall through
        }
    }
    return new AnnotatedLargeText<FolderComputation<I>>(eventsFile, Charsets.UTF_8, false, this);
}

From source file:it.qualityGate.QualityGateTest.java

private void verifyQGStatusInPostTask(BuildResult buildResult, String projectKey, String taskStatus,
        String qgStatus) throws IOException {
    List<String> logsLines = FileUtils.readLines(orchestrator.getServer().getCeLogs(), Charsets.UTF_8);
    List<String> postTaskLogLines = extractPosttaskPluginLogs(extractCeTaskId(buildResult), logsLines);

    assertThat(postTaskLogLines).hasSize(1);
    assertThat(postTaskLogLines.iterator().next()).contains("CeTask[" + taskStatus + "]")
            .contains("Project[" + projectKey + "]").contains("QualityGate[" + qgStatus + "]");
}

From source file:ai.api.AIDataService.java

protected String doTextRequest(@NonNull final String endpoint, @NonNull final String requestJson,
        @Nullable final Map<String, String> additionalHeaders)
        throws MalformedURLException, AIServiceException {

    HttpURLConnection connection = null;

    try {/*from  w ww.  j a  v a  2s. c o m*/

        final URL url = new URL(endpoint);

        final String queryData = requestJson;

        Log.d(TAG, "Request json: " + queryData);

        if (config.getProxy() != null) {
            connection = (HttpURLConnection) url.openConnection(config.getProxy());
        } else {
            connection = (HttpURLConnection) url.openConnection();
        }

        connection.setRequestMethod("POST");
        connection.setDoOutput(true);
        connection.addRequestProperty("Authorization", "Bearer " + config.getApiKey());
        connection.addRequestProperty("Content-Type", "application/json; charset=utf-8");
        connection.addRequestProperty("Accept", "application/json");

        if (additionalHeaders != null) {
            for (final Map.Entry<String, String> entry : additionalHeaders.entrySet()) {
                connection.addRequestProperty(entry.getKey(), entry.getValue());
            }
        }

        connection.connect();

        final BufferedOutputStream outputStream = new BufferedOutputStream(connection.getOutputStream());
        IOUtils.write(queryData, outputStream, Charsets.UTF_8);
        outputStream.close();

        final InputStream inputStream = new BufferedInputStream(connection.getInputStream());
        final String response = IOUtils.toString(inputStream, Charsets.UTF_8);
        inputStream.close();

        return response;
    } catch (final IOException e) {
        if (connection != null) {
            try {
                final InputStream errorStream = connection.getErrorStream();
                if (errorStream != null) {
                    final String errorString = IOUtils.toString(errorStream, Charsets.UTF_8);
                    Log.d(TAG, "" + errorString);
                    return errorString;
                } else {
                    throw new AIServiceException("Can't connect to the api.ai service.", e);
                }
            } catch (final IOException ex) {
                Log.w(TAG, "Can't read error response", ex);
            }
        }
        Log.e(TAG,
                "Can't make request to the API.AI service. Please, check connection settings and API access token.",
                e);
        throw new AIServiceException(
                "Can't make request to the API.AI service. Please, check connection settings and API access token.",
                e);

    } finally {
        if (connection != null) {
            connection.disconnect();
        }
    }

}

From source file:io.druid.data.input.impl.PrefetchableTextFilesFirehoseFactory.java

@Override
public Firehose connect(StringInputRowParser firehoseParser, File temporaryDirectory) throws IOException {
    if (maxCacheCapacityBytes == 0 && maxFetchCapacityBytes == 0) {
        return super.connect(firehoseParser, temporaryDirectory);
    }/* ww  w .  j a  v  a2 s  .c o m*/

    if (objects == null) {
        objects = ImmutableList.copyOf(Preconditions.checkNotNull(initObjects(), "objects"));
    }

    Preconditions.checkState(temporaryDirectory.exists(), "temporaryDirectory[%s] does not exist",
            temporaryDirectory);
    Preconditions.checkState(temporaryDirectory.isDirectory(), "temporaryDirectory[%s] is not a directory",
            temporaryDirectory);

    // fetchExecutor is responsible for background data fetching
    final ExecutorService fetchExecutor = createFetchExecutor();

    return new FileIteratingFirehose(new Iterator<LineIterator>() {
        // When prefetching is enabled, fetchFiles and nextFetchIndex are updated by the fetchExecutor thread, but
        // read by both the main thread (in hasNext()) and the fetchExecutor thread (in fetch()). To guarantee that
        // fetchFiles and nextFetchIndex are updated atomically, this lock must be held before updating
        // them.
        private final Object fetchLock = new Object();
        private final LinkedBlockingQueue<FetchedFile> fetchFiles = new LinkedBlockingQueue<>();

        // Number of bytes currently fetched files.
        // This is updated when a file is successfully fetched or a fetched file is deleted.
        private final AtomicLong fetchedBytes = new AtomicLong(0);
        private final boolean cacheInitialized;
        private final boolean prefetchEnabled;

        private Future<Void> fetchFuture;
        private int cacheIterateIndex;
        // nextFetchIndex indicates which object should be downloaded when fetch is triggered.
        private int nextFetchIndex;

        {
            cacheInitialized = totalCachedBytes > 0;
            prefetchEnabled = maxFetchCapacityBytes > 0;

            if (cacheInitialized) {
                nextFetchIndex = cacheFiles.size();
            }
            if (prefetchEnabled) {
                fetchIfNeeded(totalCachedBytes);
            }
        }

        private void fetchIfNeeded(long remainingBytes) {
            if ((fetchFuture == null || fetchFuture.isDone()) && remainingBytes <= prefetchTriggerBytes) {
                fetchFuture = fetchExecutor.submit(() -> {
                    fetch();
                    return null;
                });
            }
        }

        /**
         * Fetch objects to a local disk up to {@link PrefetchableTextFilesFirehoseFactory#maxFetchCapacityBytes}.
         * This method is not thread safe and must be called by a single thread.  Note that even
         * {@link PrefetchableTextFilesFirehoseFactory#maxFetchCapacityBytes} is 0, at least 1 file is always fetched.
         * This is for simplifying design, and should be improved when our client implementations for cloud storages
         * like S3 support range scan.
         */
        private void fetch() throws Exception {
            for (int i = nextFetchIndex; i < objects.size()
                    && fetchedBytes.get() <= maxFetchCapacityBytes; i++) {
                final ObjectType object = objects.get(i);
                LOG.info("Fetching object[%s], fetchedBytes[%d]", object, fetchedBytes.get());
                final File outFile = File.createTempFile(FETCH_FILE_PREFIX, null, temporaryDirectory);
                fetchedBytes.addAndGet(download(object, outFile, 0));
                synchronized (fetchLock) {
                    fetchFiles.put(new FetchedFile(object, outFile));
                    nextFetchIndex++;
                }
            }
        }

        /**
         * Downloads an object. It retries downloading {@link PrefetchableTextFilesFirehoseFactory#maxFetchRetry}
         * times and throws an exception.
         *
         * @param object   an object to be downloaded
         * @param outFile  a file which the object data is stored
         * @param tryCount current retry count
         *
         * @return number of downloaded bytes
         *
         * @throws IOException
         */
        private long download(ObjectType object, File outFile, int tryCount) throws IOException {
            try (final InputStream is = openObjectStream(object);
                    final CountingOutputStream cos = new CountingOutputStream(new FileOutputStream(outFile))) {
                IOUtils.copy(is, cos);
                return cos.getCount();
            } catch (IOException e) {
                final int nextTry = tryCount + 1;
                if (!Thread.currentThread().isInterrupted() && nextTry < maxFetchRetry) {
                    LOG.error(e, "Failed to download object[%s], retrying (%d of %d)", object, nextTry,
                            maxFetchRetry);
                    outFile.delete();
                    return download(object, outFile, nextTry);
                } else {
                    LOG.error(e, "Failed to download object[%s], retries exhausted, aborting", object);
                    throw e;
                }
            }
        }

        @Override
        public boolean hasNext() {
            synchronized (fetchLock) {
                return (cacheInitialized && cacheIterateIndex < cacheFiles.size()) || !fetchFiles.isEmpty()
                        || nextFetchIndex < objects.size();
            }
        }

        @Override
        public LineIterator next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            // If fetch() fails, hasNext() always returns true because nextFetchIndex must be smaller than the number
            // of objects, which means next() is always called. The below method checks that fetch() threw an exception
            // and propagates it if exists.
            checkFetchException();

            final OpenedObject openedObject;

            try {
                // Check cache first
                if (cacheInitialized && cacheIterateIndex < cacheFiles.size()) {
                    final FetchedFile fetchedFile = cacheFiles.get(cacheIterateIndex++);
                    openedObject = new OpenedObject(fetchedFile, getNoopCloser());
                } else if (prefetchEnabled) {
                    openedObject = openObjectFromLocal();
                } else {
                    openedObject = openObjectFromRemote();
                }

                final InputStream stream = wrapObjectStream(openedObject.object, openedObject.objectStream);

                return new ResourceCloseableLineIterator(new InputStreamReader(stream, Charsets.UTF_8),
                        openedObject.resourceCloser);
            } catch (IOException e) {
                throw Throwables.propagate(e);
            }
        }

        private void checkFetchException() {
            if (fetchFuture != null && fetchFuture.isDone()) {
                try {
                    fetchFuture.get();
                    fetchFuture = null;
                } catch (InterruptedException | ExecutionException e) {
                    throw Throwables.propagate(e);
                }
            }
        }

        private OpenedObject openObjectFromLocal() throws IOException {
            final FetchedFile fetchedFile;
            final Closeable resourceCloser;

            if (!fetchFiles.isEmpty()) {
                // If there are already fetched files, use them
                fetchedFile = fetchFiles.poll();
                resourceCloser = cacheIfPossibleAndGetCloser(fetchedFile, fetchedBytes);
                fetchIfNeeded(fetchedBytes.get());
            } else {
                // Otherwise, wait for fetching
                try {
                    fetchIfNeeded(fetchedBytes.get());
                    fetchedFile = fetchFiles.poll(fetchTimeout, TimeUnit.MILLISECONDS);
                    if (fetchedFile == null) {
                        // Check the latest fetch is failed
                        checkFetchException();
                        // Or throw a timeout exception
                        throw new RuntimeException(new TimeoutException());
                    }
                    resourceCloser = cacheIfPossibleAndGetCloser(fetchedFile, fetchedBytes);
                    // trigger fetch again for subsequent next() calls
                    fetchIfNeeded(fetchedBytes.get());
                } catch (InterruptedException e) {
                    throw Throwables.propagate(e);
                }
            }
            return new OpenedObject(fetchedFile, resourceCloser);
        }

        private OpenedObject openObjectFromRemote() throws IOException {
            final OpenedObject openedObject;
            final Closeable resourceCloser = getNoopCloser();

            if (totalCachedBytes < maxCacheCapacityBytes) {
                LOG.info("Caching object[%s]", objects.get(nextFetchIndex));
                try {
                    // Since maxFetchCapacityBytes is 0, at most one file is fetched.
                    fetch();
                    FetchedFile fetchedFile = fetchFiles.poll();
                    if (fetchedFile == null) {
                        throw new ISE("Cannot fetch object[%s]", objects.get(nextFetchIndex));
                    }
                    cacheIfPossible(fetchedFile);
                    fetchedBytes.addAndGet(-fetchedFile.length());
                    openedObject = new OpenedObject(fetchedFile, resourceCloser);
                } catch (Exception e) {
                    throw Throwables.propagate(e);
                }
            } else {
                final ObjectType object = objects.get(nextFetchIndex++);
                LOG.info("Reading object[%s]", object);
                openedObject = new OpenedObject(object, openObjectStream(object), resourceCloser);
            }
            return openedObject;
        }
    }, firehoseParser, () -> {
        fetchExecutor.shutdownNow();
        try {
            Preconditions.checkState(fetchExecutor.awaitTermination(fetchTimeout, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new ISE("Failed to shutdown fetch executor during close");
        }
    });
}

From source file:cz.cas.lib.proarc.common.export.cejsh.CejshBuilder.java

File writeProperties(File packageFolder, int articleCount) throws IOException, FileNotFoundException {
    File propertiesFile = new File(packageFolder, IMPORT_PROPERTIES_FILENAME);
    Properties properties = new Properties();
    gcalendar.setTimeInMillis(System.currentTimeMillis());
    String importDate = DatatypeConverter.printDateTime(gcalendar);
    properties.setProperty(PROP_IMPORT_INFODATE, importDate);
    properties.setProperty(PROP_IMPORT_OBJECTS, String.valueOf(articleCount));
    properties.setProperty(PROP_IMPORT_CONTENT_FILES, "0");
    properties.setProperty(PROP_IMPORT_BWMETA_FILES, "1");
    Writer propsWriter = new NoCommentsWriter(
            new OutputStreamWriter(new FileOutputStream(propertiesFile), Charsets.UTF_8));
    try {//  w ww  .  ja  v  a2 s .co m
        properties.store(propsWriter, null);
        return propertiesFile;
    } finally {
        propsWriter.close();
    }
}

From source file:com.streamsets.pipeline.stage.origin.tcp.TestTCPServerSource.java

@Test
public void flumeAvroIpc() throws StageException, IOException, ExecutionException, InterruptedException {

    final Charset charset = Charsets.UTF_8;
    final TCPServerSourceConfig configBean = createConfigBean(charset);
    configBean.tcpMode = TCPMode.FLUME_AVRO_IPC;
    configBean.dataFormat = DataFormat.TEXT;
    configBean.bindAddress = "0.0.0.0";

    final int batchSize = 5;
    final String outputLane = "output";

    final TCPServerSource source = new TCPServerSource(configBean);
    final PushSourceRunner runner = new PushSourceRunner.Builder(TCPServerDSource.class, source)
            .addOutputLane(outputLane).setOnRecordError(OnRecordError.TO_ERROR).build();

    runner.runInit();/*from   w ww.j  a  v a  2  s.  com*/

    runner.runProduce(Collections.emptyMap(), batchSize, out -> {
        final Map<String, List<Record>> outputMap = out.getRecords();
        assertThat(outputMap, hasKey(outputLane));
        final List<Record> records = outputMap.get(outputLane);
        assertThat(records, hasSize(batchSize));
        for (int i = 0; i < batchSize; i++) {
            assertThat(records.get(i).get("/" + TextDataParserFactory.TEXT_FIELD_NAME),
                    fieldWithValue(getFlumeAvroIpcEventName(i)));
        }
        runner.setStop();
    });

    final AvroSourceProtocol client = SpecificRequestor.getClient(AvroSourceProtocol.class,
            new NettyTransceiver(
                    new InetSocketAddress("localhost", Integer.parseInt(configBean.ports.get(0)))));

    List<AvroFlumeEvent> events = new LinkedList<>();
    for (int i = 0; i < batchSize; i++) {
        AvroFlumeEvent avroEvent = new AvroFlumeEvent();

        avroEvent.setHeaders(new HashMap<CharSequence, CharSequence>());
        avroEvent.setBody(ByteBuffer.wrap(getFlumeAvroIpcEventName(i).getBytes()));
        events.add(avroEvent);
    }

    Status status = client.appendBatch(events);

    assertThat(status, equalTo(Status.OK));

    runner.waitOnProduce();
}

From source file:jenkins.model.RunIdMigrator.java

/** Inverse of {@link #doMigrate}. */
private void unmigrateBuildsDir(File builds) throws Exception {
    File mapFile = new File(builds, MAP_FILE);
    if (!mapFile.isFile()) {
        System.err.println(builds + " does not look to have been migrated yet; skipping");
        return;//  w  ww  . j  a  v  a 2s  . c om
    }
    for (File build : builds.listFiles()) {
        int number;
        try {
            number = Integer.parseInt(build.getName());
        } catch (NumberFormatException x) {
            continue;
        }
        File buildXml = new File(build, "build.xml");
        if (!buildXml.isFile()) {
            System.err.println(buildXml + " did not exist");
            continue;
        }
        String xml = FileUtils.readFileToString(buildXml, Charsets.UTF_8);
        Matcher m = TIMESTAMP_ELT.matcher(xml);
        if (!m.find()) {
            System.err.println(buildXml + " did not contain <timestamp> as expected");
            continue;
        }
        long timestamp = Long.parseLong(m.group(1));
        String nl = m.group(2);
        xml = m.replaceFirst("  <number>" + number + "</number>" + nl);
        m = ID_ELT.matcher(xml);
        String id;
        if (m.find()) {
            id = m.group(1);
            xml = m.replaceFirst("");
        } else {
            // Post-migration build. We give it a new ID based on its timestamp.
            id = legacyIdFormatter.format(new Date(timestamp));
        }
        FileUtils.write(buildXml, xml, Charsets.UTF_8);
        if (!build.renameTo(new File(builds, id))) {
            System.err.println(build + " could not be renamed");
        }
        Util.createSymlink(builds, id, Integer.toString(number), StreamTaskListener.fromStderr());
    }
    Util.deleteFile(mapFile);
    System.err.println(builds + " has been restored to its original format");
}

From source file:alluxio.multi.process.MultiProcessCluster.java

/**
 * Writes the contents of {@link #mProperties} to the configuration file.
 *//*from  www .  j a  va  2  s  . c om*/
private void writeConf() throws IOException {
    File confDir = new File(mWorkDir, "conf");
    confDir.mkdirs();
    StringBuilder sb = new StringBuilder();
    for (Entry<PropertyKey, String> entry : mProperties.entrySet()) {
        sb.append(String.format("%s=%s%n", entry.getKey(), entry.getValue()));
    }
    try (FileOutputStream fos = new FileOutputStream(new File(confDir, "alluxio-site.properties"))) {
        fos.write(sb.toString().getBytes(Charsets.UTF_8));
    }
}

From source file:example.TestLineRecordReader.java

@Test
public void testUncompressedInputCustomDelimiterPosValue() throws Exception {
    Configuration conf = new Configuration();
    conf.setInt("io.file.buffer.size", 10);
    conf.setInt(org.apache.hadoop.mapreduce.lib.input.LineRecordReader.MAX_LINE_LENGTH, Integer.MAX_VALUE);
    String inputData = "abcdefghij++kl++mno";
    Path inputFile = createInputFile(conf, inputData);
    String delimiter = "++";
    byte[] recordDelimiterBytes = delimiter.getBytes(Charsets.UTF_8);
    int splitLength = 15;
    FileSplit split = new FileSplit(inputFile, 0, splitLength, (String[]) null);
    TaskAttemptContext context = new TaskAttemptContextImpl(conf, new TaskAttemptID());
    LineRecordReader reader = new LineRecordReader(recordDelimiterBytes);
    reader.initialize(split, context);/* ww  w  . j  a v  a  2s  . c om*/
    // Get first record: "abcdefghij"
    assertTrue("Expected record got nothing", reader.nextKeyValue());
    LongWritable key = reader.getCurrentKey();
    Text value = reader.getCurrentValue();
    assertEquals("Wrong length for record value", 10, value.getLength());
    assertEquals("Wrong position after record read", 0, key.get());
    // Get second record: "kl"
    assertTrue("Expected record got nothing", reader.nextKeyValue());
    assertEquals("Wrong length for record value", 2, value.getLength());
    // Key should be 12 right after "abcdefghij++"
    assertEquals("Wrong position after record read", 12, key.get());
    // Get third record: "mno"
    assertTrue("Expected record got nothing", reader.nextKeyValue());
    assertEquals("Wrong length for record value", 3, value.getLength());
    // Key should be 16 right after "abcdefghij++kl++"
    assertEquals("Wrong position after record read", 16, key.get());
    assertFalse(reader.nextKeyValue());
    // Key should be 19 right after "abcdefghij++kl++mno"
    assertEquals("Wrong position after record read", 19, key.get());
    // after refresh should be empty
    key = reader.getCurrentKey();
    assertNull("Unexpected key returned", key);
    reader.close();
    split = new FileSplit(inputFile, splitLength, inputData.length() - splitLength, (String[]) null);
    reader = new LineRecordReader(recordDelimiterBytes);
    reader.initialize(split, context);
    // No record is in the second split because the second split dropped
    // the first record, which was already reported by the first split.
    assertFalse("Unexpected record returned", reader.nextKeyValue());
    key = reader.getCurrentKey();
    assertNull("Unexpected key returned", key);
    reader.close();

    // multi char delimiter with starting part of the delimiter in the data
    inputData = "abcd+efgh++ijk++mno";
    inputFile = createInputFile(conf, inputData);
    splitLength = 5;
    split = new FileSplit(inputFile, 0, splitLength, (String[]) null);
    reader = new LineRecordReader(recordDelimiterBytes);
    reader.initialize(split, context);
    // Get first record: "abcd+efgh"
    assertTrue("Expected record got nothing", reader.nextKeyValue());
    key = reader.getCurrentKey();
    value = reader.getCurrentValue();
    assertEquals("Wrong position after record read", 0, key.get());
    assertEquals("Wrong length for record value", 9, value.getLength());
    // should have jumped over the delimiter, no record
    assertFalse(reader.nextKeyValue());
    assertEquals("Wrong position after record read", 11, key.get());
    // after refresh should be empty
    key = reader.getCurrentKey();
    assertNull("Unexpected key returned", key);
    reader.close();
    // next split: check for duplicate or dropped records
    split = new FileSplit(inputFile, splitLength, inputData.length() - splitLength, (String[]) null);
    reader = new LineRecordReader(recordDelimiterBytes);
    reader.initialize(split, context);
    assertTrue("Expected record got nothing", reader.nextKeyValue());
    key = reader.getCurrentKey();
    value = reader.getCurrentValue();
    // Get second record: "ijk" first in this split
    assertEquals("Wrong position after record read", 11, key.get());
    assertEquals("Wrong length for record value", 3, value.getLength());
    // Get third record: "mno" second in this split
    assertTrue("Expected record got nothing", reader.nextKeyValue());
    assertEquals("Wrong position after record read", 16, key.get());
    assertEquals("Wrong length for record value", 3, value.getLength());
    // should be at the end of the input
    assertFalse(reader.nextKeyValue());
    assertEquals("Wrong position after record read", 19, key.get());
    reader.close();

    inputData = "abcd|efgh|+|ij|kl|+|mno|pqr";
    inputFile = createInputFile(conf, inputData);
    delimiter = "|+|";
    recordDelimiterBytes = delimiter.getBytes(Charsets.UTF_8);
    // walking over the buffer and split sizes checks for proper processing
    // of the ambiguous bytes of the delimiter
    for (int bufferSize = 1; bufferSize <= inputData.length(); bufferSize++) {
        for (int splitSize = 1; splitSize < inputData.length(); splitSize++) {
            // track where we are in the inputdata
            int keyPosition = 0;
            conf.setInt("io.file.buffer.size", bufferSize);
            split = new FileSplit(inputFile, 0, bufferSize, (String[]) null);
            reader = new LineRecordReader(recordDelimiterBytes);
            reader.initialize(split, context);
            // Get the first record: "abcd|efgh" always possible
            assertTrue("Expected record got nothing", reader.nextKeyValue());
            key = reader.getCurrentKey();
            value = reader.getCurrentValue();
            assertTrue("abcd|efgh".equals(value.toString()));
            // Position should be 0 right at the start
            assertEquals("Wrong position after record read", keyPosition, key.get());
            // Position should be 12 right after the first "|+|"
            keyPosition = 12;
            // get the next record: "ij|kl" if the split/buffer allows it
            if (reader.nextKeyValue()) {
                // check the record info: "ij|kl"
                assertTrue("ij|kl".equals(value.toString()));
                assertEquals("Wrong position after record read", keyPosition, key.get());
                // Position should be 20 after the second "|+|"
                keyPosition = 20;
            }
            // get the third record: "mno|pqr" if the split/buffer allows it
            if (reader.nextKeyValue()) {
                // check the record info: "mno|pqr"
                assertTrue("mno|pqr".equals(value.toString()));
                assertEquals("Wrong position after record read", keyPosition, key.get());
                // Position should be the end of the input
                keyPosition = inputData.length();
            }
            assertFalse("Unexpected record returned", reader.nextKeyValue());
            // no more records can be read we should be at the last position
            assertEquals("Wrong position after record read", keyPosition, key.get());
            // after refresh should be empty
            key = reader.getCurrentKey();
            assertNull("Unexpected key returned", key);
            reader.close();
        }
    }
}