Revert "Allow individual unicode surrogates strings"

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, 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 "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
@@ skipping 1089 matching lines @@
   EXPECT(Dart_IsString(utf8_str));
 
   uint8_t invalid[] = { 0xE4, 0xBA };  // underflow.
   Dart_Handle invalid_str = Dart_NewStringFromUTF8(invalid,
                                                    ARRAY_SIZE(invalid));
   EXPECT(Dart_IsError(invalid_str));
 }
 
 
 TEST_CASE(MalformedStringToUTF8) {
-  // 1D11E = treble clef
-  // [0] should be high surrogate D834
-  // [1] should be low surrogate DD1E
-  // Strings are allowed to have individual or out of order surrogates, even
-  // if that doesn't make sense as renderable characters.
   const char* kScriptChars =
-      "String lowSurrogate() {"
+      "String testMain() {"
       "  return '\\u{1D11E}'[1];"
-      "}"
-      "String highSurrogate() {"
-      "  return '\\u{1D11E}'[0];"
-      "}"
-      "String reversed() => lowSurrogate() + highSurrogate();";
+      "}";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
-  Dart_Handle str1 = Dart_Invoke(lib, NewString("lowSurrogate"), 0, NULL);
+  Dart_Handle str1 = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(str1);
 
   uint8_t* utf8_encoded = NULL;
   intptr_t utf8_length = 0;
   Dart_Handle result = Dart_StringToUTF8(str1, &utf8_encoded, &utf8_length);
   EXPECT_VALID(result);
   EXPECT_EQ(3, utf8_length);
   EXPECT_EQ(237, static_cast<intptr_t>(utf8_encoded[0]));
   EXPECT_EQ(180, static_cast<intptr_t>(utf8_encoded[1]));
   EXPECT_EQ(158, static_cast<intptr_t>(utf8_encoded[2]));
 
   Dart_Handle str2 = Dart_NewStringFromUTF8(utf8_encoded, utf8_length);
-  EXPECT_VALID(str2);  // Standalone low surrogate, but still valid
-
-  Dart_Handle reversed = Dart_Invoke(lib, NewString("reversed"), 0, NULL);
-  EXPECT_VALID(reversed);  // This is also allowed.
-  uint8_t* utf8_encoded_reversed = NULL;
-  intptr_t utf8_length_reversed = 0;
-  result = Dart_StringToUTF8(reversed,
-      &utf8_encoded_reversed, &utf8_length_reversed);
-  EXPECT_VALID(result);
-  EXPECT_EQ(6, utf8_length_reversed);
-  uint8_t expected[6] = {237, 180, 158, 237, 160, 180};
-  for (int i = 0; i < 6; i++) {
-    EXPECT_EQ(expected[i], utf8_encoded_reversed[i]);
-  }
+  EXPECT(Dart_IsError(str2));  // Invalid UTF-8.
 }
 
 
 static void ExternalStringCallbackFinalizer(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
 
 TEST_CASE(ExternalStringCallback) {
   int peer8 = 40;
@@ skipping 8271 matching lines @@
   // Heartbeat test.
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 }  // namespace dart