@Override
    public InputChannelResult readRecord(Record target) throws IOException, InterruptedException {

      if ((target = it.next(target)) != null) {
        // everything comes from the same source channel and buffer in this mock
        notifyRecordIsAvailable(0);
        return InputChannelResult.INTERMEDIATE_RECORD_FROM_BUFFER;
      } else {
        return InputChannelResult.END_OF_STREAM;
      }
    }
  public void testStringSorting() {
    File input = null;
    File sorted = null;

    try {
      // the source file
      input = generateFileWithStrings(300000, "http://some-uri.com/that/is/a/common/prefix/to/all");

      // the sorted file
      sorted = File.createTempFile("sorted_strings", "txt");

      String[] command = {
        "/bin/bash",
        "-c",
        "export LC_ALL=\"C\" && cat \""
            + input.getAbsolutePath()
            + "\" | sort > \""
            + sorted.getAbsolutePath()
            + "\""
      };

      Process p = null;
      try {
        p = Runtime.getRuntime().exec(command);
        int retCode = p.waitFor();
        if (retCode != 0) {
          throw new Exception("Command failed with return code " + retCode);
        }
        p = null;
      } finally {
        if (p != null) {
          p.destroy();
        }
      }

      // sort the data
      UnilateralSortMerger<String> sorter = null;
      BufferedReader reader = null;
      BufferedReader verifyReader = null;

      try {
        MemoryManager mm = new DefaultMemoryManager(1024 * 1024, 1);
        IOManager ioMan = new IOManager();

        TypeSerializer<String> serializer = StringSerializer.INSTANCE;
        TypeComparator<String> comparator = new StringComparator(true);

        reader = new BufferedReader(new FileReader(input));
        MutableObjectIterator<String> inputIterator = new StringReaderMutableObjectIterator(reader);

        sorter =
            new UnilateralSortMerger<String>(
                mm,
                ioMan,
                inputIterator,
                new DummyInvokable(),
                new RuntimeStatelessSerializerFactory<String>(serializer, String.class),
                comparator,
                1.0,
                4,
                0.8f);

        MutableObjectIterator<String> sortedData = sorter.getIterator();

        reader.close();

        // verify
        verifyReader = new BufferedReader(new FileReader(sorted));
        String next;

        while ((next = verifyReader.readLine()) != null) {
          String nextFromStratoSort = sortedData.next("");

          Assert.assertNotNull(nextFromStratoSort);
          Assert.assertEquals(next, nextFromStratoSort);
        }
      } finally {
        if (reader != null) {
          reader.close();
        }
        if (verifyReader != null) {
          verifyReader.close();
        }
        if (sorter != null) {
          sorter.close();
        }
      }
    } catch (Exception e) {
      System.err.println(e.getMessage());
      e.printStackTrace();
      Assert.fail(e.getMessage());
    } finally {
      if (input != null) {
        input.delete();
      }
      if (sorted != null) {
        sorted.delete();
      }
    }
  }