private static int countLines(String str){
   String[] lines = str.split("\r\n|\r|\n");
   return  lines.length;
}

Bug

The program doesn't count words correctly, for example in "a text like this", because it counts every whitespace character as a word, without handling consecutive whitespace characters.

Reading character by character is inefficient

Reading a file character by character is not very efficient. It would be better to use a buffered reader and process the file line by line. Here's an example of doing that, which also solves the bug with word counting:

long[] counts = new long[3];
try(InputStream in = new FileInputStream(filename);
    BufferedReader reader = new BufferedReader(new InputStreamReader(in, Charset.forName("UTF-8")))
) {
    String line;
    while ((line = reader.readLine()) != null) {
        counts[2]++;
        counts[1] += line.split("\\s+").length;
        counts[0] += line.length() + 1;
    }
}
return counts;

This might still not be accurate, and probably there are corner cases where it will not count words correctly, but it's still more accurate than the original.

Encapsulation

The implementation doesn't encapsulate well the results. It returns a long[], which is not great because you have to remember the array indexes that correspond to characters, words, lines, which is error prone. Even if you add constants like CHARS_INDEX = 0, WORDS_INDEX = 1 to eliminate magic numbers, it will not solve the encapsulation problem: users of the function will know too much about the internal implementation, that it uses a long[] for storage. It would be cleaner to create a dedicated CountResult class to encapsulate the results.

For example:

private static class CountResult {
    private final long chars;
    private final long words;
    private final long lines;

    private CountResult(long chars, long words, long lines) {
        this.chars = chars;
        this.words = words;
        this.lines = lines;
    }
}

And then use it like this:

long chars = 0;
long words = 0;
long lines = 0;
while ((line = reader.readLine()) != null) {
    lines++;
    words += line.split("\\s+").length;
    chars += line.length() + 1;
}
return new CountResult(chars, words, lines);

Callers will not need to remember indexes, the counts will be accessible intuitively by names.

Unused variables

You have some unused variables:

Reader buffer = new BufferedReader(reader)

String newLineChar = System.lineSeparator();

It would be better to remove them.

Check this code.

class LineCountTest
{
    private static final String test = "This is a\ntest string\n\n\n";
    private static final String test2 = "This is a\ntest string\n\n\n ";

    public static void main(String[] args) {
        System.out.println("Line count: " + countLines(test));
        System.out.println("Line count: " + countLines(test2));
    }

    private static int countLines(String s) {
        return (s + " ").split("\r?\n").length;
    }
}

This will solve your problem.

This code splits the string by \r\n or \n and return the number of lines.

The additional blank space is added so that the last line is counted even if it is empty.

The BufferedReader is behaving correctly.

The condition line != null is causing the problem.

In the string test, there is nothing after the last \n, which is read as null by BufferedReader#readLine() and thats why the loop terminates and the output is 4.

In the string test2, there is a blank space after the last \n, which allows another iteration and the output is 5.

If you are using java 7 or higher version you can directly read all the lines to a List using readAllLines method. That would be easy

readAllLines

List<String> lines = Files.readAllLines(Paths.get(fileName), Charset.defaultCharset());

Then the size of the list will return you number of lines in the file

int noOfLines = lines.size();

try

    int words = 0;
    int lines = 0;
    int chars = 0;
    while(in.hasNextLine())  {
        lines++;
        String line = in.nextLine();
        chars += line.length();
        words += new StringTokenizer(line, " ,").countTokens();
    }