Some small changes to make the vm dart:mirrors somewhat closer to the

runtime/tests/vm/dart/isolate_mirror_local_test.dart

 // 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.
 //
-// Dart test program for checking implemention of IsolateMirror when
+// Dart test program for checking implemention of MirrorSystem when
 // inspecting the current isolate.
 
 #library('isolate_mirror_local_test');
 
 #import('dart:isolate');
 #import('dart:mirrors');
 
 ReceivePort exit_port;
 Set expectedTests;
 
@@ skipping 109 matching lines @@
                 'main, '
                 'methodWithError, '
                 'methodWithException, '
                 'myVar, '
                 'myVar=, '
                 'sort, '
                 'testBoolInstanceMirror, '
                 'testCustomInstanceMirror, '
                 'testDone, '
                 'testIntegerInstanceMirror, '
-                'testIsolateMirror, '
                 'testLibrariesMap, '
                 'testMirrorErrors, '
+                'testMirrorSystem, '
                 'testNullInstanceMirror, '
                 'testRootLibraryMirror, '
                 'testStringInstanceMirror]',
                 '$keys');
 
   // Check that the classes map is complete.
   keys = lib_mirror.classes().getKeys();
   sort(keys);
   Expect.equals('['
                 'MyClass, '
@@ skipping 13 matching lines @@
                 'main, '
                 'methodWithError, '
                 'methodWithException, '
                 'myVar, '
                 'myVar=, '
                 'sort, '
                 'testBoolInstanceMirror, '
                 'testCustomInstanceMirror, '
                 'testDone, '
                 'testIntegerInstanceMirror, '
-                'testIsolateMirror, '
                 'testLibrariesMap, '
                 'testMirrorErrors, '
+                'testMirrorSystem, '
                 'testNullInstanceMirror, '
                 'testRootLibraryMirror, '
                 'testStringInstanceMirror]',
                 '$keys');
 
   // Check that the variables map is complete.
   keys = lib_mirror.variables().getKeys();
   sort(keys);
   Expect.equals('['
                 'exit_port, '
@@ skipping 66 matching lines @@
   Expect.equals('Object', oom_cls.superclass().simpleName);
   Expect.isTrue(oom_cls.defaultFactory() === null);
   Expect.equals('dart:core', oom_cls.library.simpleName);
   Expect.isTrue(oom_cls.isClass);
   Expect.equals('Exception', oom_cls.superinterfaces()[0].simpleName);
   Expect.equals("InterfaceMirror on 'OutOfMemoryException'",
                 oom_cls.toString());
   testDone('testLibrariesMap');
 }
 
-void testIsolateMirror(IsolateMirror mirror) {
-  Expect.isTrue(mirror.debugName.contains('main'));
-  testRootLibraryMirror(mirror.rootLibrary);
-  testLibrariesMap(mirror.libraries());
-  testDone('testIsolateMirror');
+void testMirrorSystem(MirrorSystem mirrors) {
+  Expect.isTrue(mirrors.isolate.debugName.contains('main'));
+  testRootLibraryMirror(mirrors.rootLibrary);
+  testLibrariesMap(mirrors.libraries());
+  testDone('testMirrorSystem');
 }
 
 void testIntegerInstanceMirror(InstanceMirror mirror) {
   // TODO(turnidge): The mirrors api exposes internal vm
   // implementation class names.  Is this okay?
   Expect.equals('Smi', mirror.getClass().simpleName);
   Expect.isTrue(mirror.hasSimpleValue);
   Expect.equals(1001, mirror.simpleValue);
   Expect.equals("InstanceMirror on <1001>", mirror.toString());
 
@@ skipping 100 matching lines @@
 
 void methodWithException() {
   throw new MyException("from methodWithException");
 }
 
 void methodWithError() {
   // We get a parse error when we try to run this function.
   +++;
 }
 
-void testMirrorErrors(IsolateMirror mirror) {
-  LibraryMirror lib_mirror = mirror.rootLibrary;
+void testMirrorErrors(MirrorSystem mirrors) {
+  LibraryMirror lib_mirror = mirrors.rootLibrary;
 
   Future<InstanceMirror> future =
       lib_mirror.invoke('methodWithException', []);
   future.handleException(
       (MirroredError exc) {
         Expect.isTrue(exc is MirroredUncaughtExceptionError);
         Expect.equals('MyException',
                       exc.exception_mirror.getClass().simpleName);
         Expect.equals('MyException: from methodWithException',
                       exc.exception_string);
@@ skipping 42 matching lines @@
         Expect.isTrue(false);
       });
 }
 
 void main() {
   // When all of the expected tests complete, the exit_port is closed,
   // allowing the program to terminate.
   exit_port = new ReceivePort();
   expectedTests = new Set<String>.from(['testRootLibraryMirror',
                                         'testLibrariesMap',
-                                        'testIsolateMirror',
+                                        'testMirrorSystem',
                                         'testIntegerInstanceMirror',
                                         'testStringInstanceMirror',
                                         'testBoolInstanceMirror',
                                         'testNullInstanceMirror',
                                         'testCustomInstanceMirror',
                                         'testMirrorErrors1',
                                         'testMirrorErrors2',
                                         'testMirrorErrors3']);
 
   // Test that an isolate can reflect on itself.
-  isolateMirrorOf(exit_port.toSendPort()).then(testIsolateMirror);
+  mirrorSystemOf(exit_port.toSendPort()).then(testMirrorSystem);
 
-  testIntegerInstanceMirror(mirrorOf(1001));
-  testStringInstanceMirror(mirrorOf('This\nis\na\nString'));
-  testBoolInstanceMirror(mirrorOf(true));
-  testNullInstanceMirror(mirrorOf(null));
-  testCustomInstanceMirror(mirrorOf(new MyClass(17)));
-  testMirrorErrors(currentIsolateMirror());
+  MirrorSystem mirrors = currentMirrorSystem();
+  testIntegerInstanceMirror(mirrors.mirrorOf(1001));
+  testStringInstanceMirror(mirrors.mirrorOf('This\nis\na\nString'));
+  testBoolInstanceMirror(mirrors.mirrorOf(true));
+  testNullInstanceMirror(mirrors.mirrorOf(null));
+  testCustomInstanceMirror(mirrors.mirrorOf(new MyClass(17)));
+  testMirrorErrors(currentMirrorSystem());
 }