Use the narrowest character width possible for substrings.

runtime/vm/object_test.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 1248 matching lines @@
               one_four_two_str.Length());
     uint32_t four_one_two[] = { 0x1D4D5, 0x1D4DE, 0x1D4E4, 0x1D4E1,
                                 'o', 'n', 'e', ' ', 'b', 'y', 't', 'e',
                                 0x05E6, 0x05D5, 0x05D5, 0x05D9, 0x05D9 };
     intptr_t four_one_two_len = sizeof(four_one_two) / sizeof(four_one_two[0]);
     EXPECT(four_one_two_str.Equals(four_one_two, four_one_two_len));
   }
 }
 
 
+TEST_CASE(StringSubStringDifferentWidth) {
+  // Create 1-byte substring from a 1-byte source string.
+  const char* onechars =
+      "\xC3\xB6\xC3\xB1\xC3\xA9";
+
+  const String& onestr = String::Handle(String::New(onechars));
+  EXPECT(!onestr.IsNull());
+  EXPECT(onestr.IsOneByteString());
+
+  const String& onesub = String::Handle(String::SubString(onestr, 0));
+  EXPECT(!onesub.IsNull());
+  EXPECT(onestr.IsOneByteString());
+  EXPECT_EQ(onesub.Length(), 3);
+
+  // Create 1- and 2-byte substrings from a 2-byte source string.
+  const char* twochars =
+      "\xC3\xB6\xC3\xB1\xC3\xA9"
+      "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93";
+
+  const String& twostr = String::Handle(String::New(twochars));
+  EXPECT(!twostr.IsNull());
+  EXPECT(twostr.IsTwoByteString());
+
+  const String& twosub1 = String::Handle(String::SubString(twostr, 0, 3));
+  EXPECT(!twosub1.IsNull());
+  EXPECT(twosub1.IsOneByteString());
+  EXPECT_EQ(twosub1.Length(), 3);
+
+  const String& twosub2 = String::Handle(String::SubString(twostr, 3));
+  EXPECT(!twosub2.IsNull());
+  EXPECT(twosub2.IsTwoByteString());
+  EXPECT_EQ(twosub2.Length(), 3);
+
+  // Create 1-, 2-, and 4-byte substrings from a 4-byte source string.
+  const char* fourchars =
+      "\xC3\xB6\xC3\xB1\xC3\xA9"
+      "\xE1\xB9\xAB\xE1\xBA\x85\xE1\xB9\x93"
+      "\xF0\x9D\x96\xBF\xF0\x9D\x97\x88\xF0\x9D\x97\x8E\xF0\x9D\x97\x8B";
+
+  const String& fourstr = String::Handle(String::New(fourchars));
+  EXPECT(!fourstr.IsNull());
+  EXPECT(fourstr.IsFourByteString());
+
+  const String& foursub1 = String::Handle(String::SubString(fourstr, 0, 3));
+  EXPECT(!foursub1.IsNull());
+  EXPECT(foursub1.IsOneByteString());
+  EXPECT_EQ(foursub1.Length(), 3);
+
+  const String& foursub2 = String::Handle(String::SubString(fourstr, 3, 3));
+  EXPECT(!foursub2.IsNull());
+  EXPECT(foursub2.IsTwoByteString());
+  EXPECT_EQ(foursub2.Length(), 3);
+
+  const String& foursub4 = String::Handle(String::SubString(fourstr, 6));
+  EXPECT_EQ(foursub4.Length(), 4);
+  EXPECT(!foursub4.IsNull());
+  EXPECT(foursub4.IsFourByteString());
+}
+
+
 TEST_CASE(StringFromUtf8Literal) {
   // Create a 1-byte string from a UTF-8 encoded string literal.
   {
     const char* src =
         "\xC2\xA0\xC2\xA1\xC2\xA2\xC2\xA3"
         "\xC2\xA4\xC2\xA5\xC2\xA6\xC2\xA7"
         "\xC2\xA8\xC2\xA9\xC2\xAA\xC2\xAB"
         "\xC2\xAC\xC2\xAD\xC2\xAE\xC2\xAF"
         "\xC2\xB0\xC2\xB1\xC2\xB2\xC2\xB3"
         "\xC2\xB4\xC2\xB5\xC2\xB6\xC2\xB7"
@@ skipping 610 matching lines @@
     cls = iterator.GetNext();
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
 #endif  // TARGET_ARCH_IA32.
 
 }  // namespace dart