Issue 4231 - Fix unstable FilterEngineTest.testSetRemoveFilterChangeCallback

libadblockplus-android/src/org/adblockplus/libadblockplus/FileSystemUtils.java

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2017 eyeo GmbH
+ *
+ * Adblock Plus is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Adblock Plus is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.adblockplus.libadblockplus;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.NoSuchElementException;
+import java.util.Scanner;
+import java.util.UUID;
+
+public class FileSystemUtils
+{
+  private static final int BUFFER_SIZE = 10 * 1024; // 10 Kb
+  private static final String CHARSET = "UTF-8";
+
+  private static String readStream(InputStream inputStream, int bufferSize) throws IOException

[sergei, 2017/05/22 13:51:04]

What about returning some bytes array or some bytes array builder (what is the
better Java class), I don't fill comfortable with String because I am afraid it
can be corrupted if the file is a binary file.

[anton, 2017/05/23 05:46:47]

Strings in java are not like null-terminated strings in c++ and can have '0x0'
or other non-text characters.
Can you provide an example of binary (few bytes) and i will test it.

[sergei, 2017/05/23 08:08:19]

I'm not talking only about null characters, what is also allowed in std::string,
though can be confusing. Try for example a file with "C0 C0" (it's a hex, two
bytes). It's an invalid UTF-8 sequence, because after 110xxxxx there should be
10xxxxxx but we put again 110xxxxx, because C0 is 11000000.

[sergei, 2017/05/23 08:17:50]

Here are http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt more tests.
Do I correctly understand that according to the doc
http://docs.oracle.com/javase/6/docs/api/java/lang/String.html ("This method
always replaces malformed-input and unmappable-character sequences with this
charset's default replacement string.") some unmappable-character sequences will
be replaced by something else?

[anton, 2017/05/23 11:11:18]

we should decide first if we consider all the files as utf-8 (as currently
assumed) or not.
If it's not, we can change API to work with byte[].

[sergei, 2017/05/23 13:00:37]

Well, C++ API is using std::istream which is for binary data, why should we
limit the type of data in the Java part which is implementation of that
interface?

[anton, 2017/05/29 11:30:02]

moved to byte array instead of String. Check out new patch set

+  {
+    StringBuilder sb = new StringBuilder();
+
+    byte buffer[] = new byte[bufferSize];
+    int bytesRead;
+    while ((bytesRead = inputStream.read(buffer)) > 0)
+    {
+      sb.append(new String(buffer, 0, bytesRead, CHARSET));
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Read all the file data to string
+   *
+   * @param file path to read data
+   * @return file data
+   * @throws java.io.IOException
+   */
+  public static String readFile(File file) throws IOException
+  {
+    FileInputStream fileInputStream = new FileInputStream(file);
+    try
+    {
+      return readStream(fileInputStream, BUFFER_SIZE);
+    }
+    finally
+    {
+      try
+      {
+        fileInputStream.close();
+      }
+      catch (IOException e)
+      {
+        // ignored
+      }
+    }
+  }
+
+  /**
+   * Write data to file (with rewriting)
+   *
+   * @param file file
+   * @param data file data
+   */
+  public static void writeFile(File file, String data) throws IOException
+  {
+    FileOutputStream fos = null;
+    try
+    {
+      fos = new FileOutputStream(file);
+      if (data != null)
+      {
+        fos.write(data.getBytes(CHARSET));
+      }
+    }
+    finally
+    {
+      if (fos != null)
+      {
+        try
+        {
+          fos.close();
+        }
+        catch (IOException e)
+        {
+          // ignored
+        }
+      }
+    }
+  }
+
+  /**
+   * Generate unique filename
+   *
+   * @param prefix prefix
+   * @param suffix suffix
+   * @return generated unique filename
+   */
+  public static String generateUniqueFileName(String prefix, String suffix)
+  {
+    StringBuilder sb = new StringBuilder();
+    if (prefix != null)
+    {
+      sb.append(prefix);
+    }
+
+    sb.append(UUID.randomUUID().toString());
+
+    if (suffix != null)
+    {
+      sb.append(suffix);
+    }
+
+    return sb.toString();
+  }
+}