When you lookup these characters and they have values like U+200E or U+200F, or really any number greater than U+007F, this means that they are going to take multiple bytes to represent in UTF8.

UTF8 and UTF16 are different ways of representing the same number. The UTF8 sequence looks like this:
You have a header byte, which indicates how long the sequence is, in the case of the RTL mark, 0xE2

If you look at 0xE2 in binary, you'll see that it looks like this: 11100010

We can tell that this is a 3 byte sequence, because the most significant 4 bits are '1110' ( (byte & 0xF0) == 0xE0 )
After these significant 4 bits, we have 0010 left over, which is going to be shifted left by 12 bits once the entire sequence has been read

In the following byte, we have 0x80 or '10000000'. The left-most bit being set and the second left-most bit not being set mean that this is a byte within a multibyte sequence, so we ignore those top 2 bits and look at the bottom 6. These are all 0, and will be shifted left by 6 bits.

In the final byte, we have 0x8F or '10001111'. You know what the top 2 bits means, and we don't have to shift left because this is the final byte in the character sequence.

So this leaves us with this: 10, 000000, and 001111.

So we use this to generate a UTF32 character like so:
( 0b0010 << 6 ) + 0b000000 == 0b10000000
( 0b10000000 << 6 ) + 0b001111 == 0b10000000001111

We're lucky with this one because the UTF32 is small enough that it doesn't need to be represented as a UTF16 surrogate pair, and as such we can use a single 16bit value for it: 0b10000000001111 is also known as 0x200F or U+200F, the Right To Left character

So you can see that UTF8 and UTF16 are different ways of encoding exactly the same thing, but in times where you can use a single UTF16 unit (without surrogates), it can take 2 or 3 byte UTF8 sequences to represent the exact same thing. This means that this test needs to do something like this, with 3 comparisons:
```C++
enum {
  UTF8_RIGHT_TO_LEFT_1 = 0xE2,
  UTF8_RIGHT_TO_LEFT_2 = 0x80,
  UTF8_RIGHT_TO_LEFT_3 = 0x8F
};
ASSERT_EQ( UTF8_RIGHT_TO_LEFT_1, node->content().text()[0] );
ASSERT_EQ( UTF8_RIGHT_TO_LEFT_2, node->content().text()[1] );
ASSERT_EQ( UTF8_RIGHT_TO_LEFT_3, node->content().text()[2] );
```

Alternatively, we can use my patch to get the UTF16 value of a character at a given index (character index, not byte index)
```C++
enum {
  UTF16_RIGHT_TO_LEFT = 0x200F
};
ASSERT_EQ( UTF16_RIGHT_TO_LEFT, node->content().utf16At( 0 ) );
```