- Add a test case to test Source code generation of all the corelibs

vm/snapshot_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 "include/dart_debugger_api.h"
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
@@ skipping 663 matching lines @@
   void WriteScript(const Script& script) {
     WriteObject(script.raw());
     UnmarkAll();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestSnapshotWriter);
 };
 
 
+static RawString* UnmangleName(const String& name) {
+  intptr_t len = name.Length();
+  intptr_t start = 0;
+  intptr_t at_pos = len;   // Position of '@' in the name.
+  intptr_t dot_pos = len;  // Position of '.' in the name.
+
+  for (int i = 0; i < name.Length(); i++) {
+    if (name.CharAt(i) == '@') {
+      ASSERT(at_pos == len);
+      at_pos = i;
+    } else if (name.CharAt(i) == '.') {
+      dot_pos = i;
+      break;
+    }
+  }
+  intptr_t limit = (at_pos < dot_pos ? at_pos : dot_pos);
+  if (start == 0 && limit == len) {
+    // This name is fine as it is.
+    return name.raw();
+  }
+
+  const String& result =
+      String::Handle(String::SubString(name, start, (limit - start)));
+
+  // Look for a second '@' now to correctly handle names like
+  // "_ReceivePortImpl@6be832b._internal@6be832b".
+  at_pos = len;
+  for (int i = dot_pos; i < name.Length(); i++) {
+    if (name.CharAt(i) == '@') {
+      ASSERT(at_pos == len);
+      at_pos = i;
+    }
+  }
+
+  intptr_t suffix_len = at_pos - dot_pos;
+  if (suffix_len > 1) {
+    // This is a named constructor.  Add the name back to the string.
+    const String& suffix =
+        String::Handle(String::SubString(name, dot_pos, suffix_len));
+    return String::Concat(result, suffix);
+  }
+
+  return result.raw();
+}
+
+
+static void GenerateSourceAndCheck(const Script& script) {

[hausner, 2012/09/07 22:12:29]

You could pass in the private_key value that is used in the library where the
script came from. It seems you would not have to unmangle the names to compare
them.

[siva, 2012/09/09 04:57:29]

Good point.

Passed in private key and got rid of the unmangle code.

On 2012/09/07 22:12:29, hausner wrote:

+  // Check if we are able to generate the source from the token stream.
+  // Rescan this source and compare the token stream to see if they are
+  // the same.
+  const TokenStream& expected_tokens = TokenStream::Handle(script.tokens());
+  TokenStream::Iterator expected_iterator(expected_tokens, 0);
+  const String& str = String::Handle(expected_tokens.GenerateSource());
+  const String& dummy_key = String::Handle(String::New(""));
+  Scanner scanner(str, dummy_key);
+  const TokenStream& reconstructed_tokens =
+      TokenStream::Handle(TokenStream::New(scanner.GetStream(), dummy_key));
+  expected_iterator.SetCurrentPosition(0);
+  TokenStream::Iterator reconstructed_iterator(reconstructed_tokens, 0);
+  Token::Kind expected_kind = expected_iterator.CurrentTokenKind();
+  Token::Kind reconstructed_kind = reconstructed_iterator.CurrentTokenKind();
+  String& expected_literal = String::Handle();
+  String& actual_literal = String::Handle();
+  while (expected_kind != Token::kEOS && reconstructed_kind != Token::kEOS) {
+    EXPECT_EQ(expected_kind, reconstructed_kind);
+    expected_literal ^= expected_iterator.CurrentLiteral();
+    expected_literal = UnmangleName(expected_literal);
+    actual_literal ^= reconstructed_iterator.CurrentLiteral();
+    actual_literal = UnmangleName(actual_literal);
+    EXPECT(expected_literal.Equals(actual_literal));
+    expected_iterator.Advance();
+    reconstructed_iterator.Advance();
+    expected_kind = expected_iterator.CurrentTokenKind();
+    reconstructed_kind = reconstructed_iterator.CurrentTokenKind();
+  }
+}
+
+
 TEST_CASE(SerializeScript) {
   const char* kScriptChars =
       "class A {\n"
       "  static bar() { return 42; }\n"
       "  static fly() { return 5; }\n"
       "  static s1() { return 'this is a string in the source'; }\n"
       "  static s2() { return 'this is a \"string\" in the source'; }\n"
       "  static s3() { return 'this is a \\\'string\\\' in \"the\" source'; }\n"
       "  static s4() { return 'this \"is\" a \"string\" in \"the\" source'; }\n"
       "}\n";
@@ skipping 45 matching lines @@
     EXPECT(expected_literal.Equals(actual_literal));
     expected_iterator.Advance();
     serialized_iterator.Advance();
     expected_kind = expected_iterator.CurrentTokenKind();
     serialized_kind = serialized_iterator.CurrentTokenKind();
   }
 
   // Check if we are able to generate the source from the token stream.
   // Rescan this source and compare the token stream to see if they are
   // the same.
-  str ^= serialized_tokens.GenerateSource();
-  const String& dummy_key = String::Handle(String::New(""));
-  Scanner scanner(str, dummy_key);
-  const TokenStream& reconstructed_tokens =
-      TokenStream::Handle(TokenStream::New(scanner.GetStream(), dummy_key));
-  expected_iterator.SetCurrentPosition(0);
-  TokenStream::Iterator reconstructed_iterator(reconstructed_tokens, 0);
-  expected_kind = expected_iterator.CurrentTokenKind();
-  Token::Kind reconstructed_kind = reconstructed_iterator.CurrentTokenKind();
-  while (expected_kind != Token::kEOS && reconstructed_kind != Token::kEOS) {
-    EXPECT_EQ(expected_kind, reconstructed_kind);
-    expected_literal ^= expected_iterator.CurrentLiteral();
-    actual_literal ^= reconstructed_iterator.CurrentLiteral();
-    EXPECT(expected_literal.Equals(actual_literal));
-    expected_iterator.Advance();
-    reconstructed_iterator.Advance();
-    expected_kind = expected_iterator.CurrentTokenKind();
-    reconstructed_kind = reconstructed_iterator.CurrentTokenKind();
-  }
+  GenerateSourceAndCheck(serialized_script);
 
   free(buffer);
 }
 
 
+static void IterateScripts(const Library& lib) {
+  const Array& lib_scripts = Array::Handle(lib.LoadedScripts());
+  Script& script = Script::Handle();
+  for (intptr_t i = 0; i < lib_scripts.Length(); i++) {
+    script ^= lib_scripts.At(i);
+    EXPECT(!script.IsNull());
+    GenerateSourceAndCheck(script);
+  }
+}
+
+TEST_CASE(GenerateSource) {
+  Library& lib = Library::Handle();
+  // Check core lib.
+  lib = Library::CoreLibrary();
+  EXPECT(!lib.IsNull());
+  IterateScripts(lib);
+
+  // Check core impl lib.
+  lib = Library::CoreImplLibrary();
+  EXPECT(!lib.IsNull());
+  IterateScripts(lib);
+
+  // Check isolate lib.
+  lib = Library::IsolateLibrary();
+  EXPECT(!lib.IsNull());
+  IterateScripts(lib);
+
+  // Check math lib.
+  lib = Library::MathLibrary();
+  EXPECT(!lib.IsNull());
+  IterateScripts(lib);
+
+  // Check mirrors lib.
+  lib = Library::MirrorsLibrary();
+  EXPECT(!lib.IsNull());
+  IterateScripts(lib);
+}
+
+
 // Only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 UNIT_TEST_CASE(FullSnapshot) {
   const char* kScriptChars =
       "class Fields  {\n"
       "  Fields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
       "  final int bigint_fld = 0xfffffffffff;\n"
       "  static int fld3;\n"
@@ skipping 743 matching lines @@
   EXPECT(Dart_ErrorHasException(result));
   EXPECT_SUBSTRING("Exception: nulltruefalse1234563.14[]100123456789\n",
                    Dart_GetError(result));
 
   Dart_ExitScope();
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart