therubyracer 0.4.7-x86-darwin-9

data/ext/v8/upstream/2.0.6/test/mjsunit/mirror-object.js

@@ -0,0 +1,227 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --expose-debug-as debug
+// Test the mirror object for objects
+
+function MirrorRefCache(json_refs) {
+  var tmp = eval('(' + json_refs + ')');
+  this.refs_ = [];
+  for (var i = 0; i < tmp.length; i++) {
+    this.refs_[tmp[i].handle] = tmp[i];
+  }
+}
+
+MirrorRefCache.prototype.lookup = function(handle) {
+  return this.refs_[handle];
+}
+
+function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) {
+  // Create mirror and JSON representation.
+  var mirror = debug.MakeMirror(obj);
+  var serializer = debug.MakeMirrorSerializer();
+  var json = JSON.stringify(serializer.serializeValue(mirror));
+  var refs = new MirrorRefCache(
+      JSON.stringify(serializer.serializeReferencedObjects()));
+
+  // Check the mirror hierachy.
+  assertTrue(mirror instanceof debug.Mirror, 'Unexpected mirror hierachy');
+  assertTrue(mirror instanceof debug.ValueMirror, 'Unexpected mirror hierachy');
+  assertTrue(mirror instanceof debug.ObjectMirror, 'Unexpected mirror hierachy');
+
+  // Check the mirror properties.
+  assertTrue(mirror.isObject(), 'Unexpected mirror');
+  assertEquals('object', mirror.type(), 'Unexpected mirror type');
+  assertFalse(mirror.isPrimitive(), 'Unexpected primitive mirror');
+  assertEquals(cls_name, mirror.className(), 'Unexpected mirror class name');
+  assertTrue(mirror.constructorFunction() instanceof debug.ObjectMirror, 'Unexpected mirror hierachy');
+  assertEquals(ctor_name, mirror.constructorFunction().name(), 'Unexpected constructor function name');
+  assertTrue(mirror.protoObject() instanceof debug.Mirror, 'Unexpected mirror hierachy');
+  assertTrue(mirror.prototypeObject() instanceof debug.Mirror, 'Unexpected mirror hierachy');
+  assertFalse(mirror.hasNamedInterceptor(), 'No named interceptor expected');
+  assertFalse(mirror.hasIndexedInterceptor(), 'No indexed interceptor expected');
+
+  var names = mirror.propertyNames();
+  var properties = mirror.properties()
+  assertEquals(names.length, properties.length);
+  for (var i = 0; i < properties.length; i++) {
+    assertTrue(properties[i] instanceof debug.Mirror, 'Unexpected mirror hierachy');
+    assertTrue(properties[i] instanceof debug.PropertyMirror, 'Unexpected mirror hierachy');
+    assertEquals('property', properties[i].type(), 'Unexpected mirror type');
+    assertEquals(names[i], properties[i].name(), 'Unexpected property name');
+  }
+  
+  for (var p in obj) {
+    var property_mirror = mirror.property(p);
+    assertTrue(property_mirror instanceof debug.PropertyMirror);
+    assertEquals(p, property_mirror.name());
+    // If the object has some special properties don't test for these.
+    if (!hasSpecialProperties) {
+      assertEquals(0, property_mirror.attributes(), property_mirror.name());
+      assertFalse(property_mirror.isReadOnly());
+      assertTrue(property_mirror.isEnum());
+      assertTrue(property_mirror.canDelete());
+    }
+  }
+
+  // Parse JSON representation and check.
+  var fromJSON = eval('(' + json + ')');
+  assertEquals('object', fromJSON.type, 'Unexpected mirror type in JSON');
+  assertEquals(cls_name, fromJSON.className, 'Unexpected mirror class name in JSON');
+  assertEquals(mirror.constructorFunction().handle(), fromJSON.constructorFunction.ref, 'Unexpected constructor function handle in JSON');
+  assertEquals('function', refs.lookup(fromJSON.constructorFunction.ref).type, 'Unexpected constructor function type in JSON');
+  assertEquals(ctor_name, refs.lookup(fromJSON.constructorFunction.ref).name, 'Unexpected constructor function name in JSON');
+  assertEquals(mirror.protoObject().handle(), fromJSON.protoObject.ref, 'Unexpected proto object handle in JSON');
+  assertEquals(mirror.protoObject().type(), refs.lookup(fromJSON.protoObject.ref).type, 'Unexpected proto object type in JSON');
+  assertEquals(mirror.prototypeObject().handle(), fromJSON.prototypeObject.ref, 'Unexpected prototype object handle in JSON');
+  assertEquals(mirror.prototypeObject().type(), refs.lookup(fromJSON.prototypeObject.ref).type, 'Unexpected prototype object type in JSON');
+  assertEquals(void 0, fromJSON.namedInterceptor, 'No named interceptor expected in JSON');
+  assertEquals(void 0, fromJSON.indexedInterceptor, 'No indexed interceptor expected in JSON');
+
+  // Check that the serialization contains all properties.
+  assertEquals(names.length, fromJSON.properties.length, 'Some properties missing in JSON');
+  for (var i = 0; i < fromJSON.properties.length; i++) {
+    var name = fromJSON.properties[i].name;
+    if (typeof name == 'undefined') name = fromJSON.properties[i].index;
+    var found = false;
+    for (var j = 0; j < names.length; j++) {
+      if (names[j] == name) {
+        // Check that serialized handle is correct.
+        assertEquals(properties[i].value().handle(), fromJSON.properties[i].ref, 'Unexpected serialized handle');
+
+        // Check that serialized name is correct.
+        assertEquals(properties[i].name(), fromJSON.properties[i].name, 'Unexpected serialized name');
+
+        // If property type is normal property type is not serialized.
+        if (properties[i].propertyType() != debug.PropertyType.Normal) {
+          assertEquals(properties[i].propertyType(), fromJSON.properties[i].propertyType, 'Unexpected serialized property type');
+        } else {
+          assertTrue(typeof(fromJSON.properties[i].propertyType) === 'undefined', 'Unexpected serialized property type');
+        }
+
+        // If there are no attributes attributes are not serialized.
+        if (properties[i].attributes() != debug.PropertyAttribute.None) {
+          assertEquals(properties[i].attributes(), fromJSON.properties[i].attributes, 'Unexpected serialized attributes');
+        } else {
+          assertTrue(typeof(fromJSON.properties[i].attributes) === 'undefined', 'Unexpected serialized attributes');
+        }
+
+        // Lookup the serialized object from the handle reference.        
+        var o = refs.lookup(fromJSON.properties[i].ref);
+        assertTrue(o != void 0, 'Referenced object is not serialized');
+
+        assertEquals(properties[i].value().type(), o.type, 'Unexpected serialized property type for ' + name);
+        if (properties[i].value().isPrimitive()) {
+          // Special check for NaN as NaN == NaN is false.
+          if (properties[i].value().isNumber() && isNaN(properties[i].value().value())) {
+            assertEquals('NaN', o.value, 'Unexpected serialized property value for ' + name);
+          } else {
+            assertEquals(properties[i].value().value(), o.value, 'Unexpected serialized property value for ' + name);
+          }
+        } else if (properties[i].value().isFunction()) {
+          assertEquals(properties[i].value().source(), o.source, 'Unexpected serialized property value for ' + name);
+        }
+        found = true;
+      }
+    }
+    assertTrue(found, '"' + name + '" not found (' + json + ')');
+  }
+}
+
+
+function Point(x,y) {
+  this.x_ = x;
+  this.y_ = y;
+}
+
+// Test a number of different objects.
+testObjectMirror({}, 'Object', 'Object');
+testObjectMirror({'a':1,'b':2}, 'Object', 'Object');
+testObjectMirror({'1':void 0,'2':null,'f':function pow(x,y){return Math.pow(x,y);}}, 'Object', 'Object');
+testObjectMirror(new Point(-1.2,2.003), 'Object', 'Point');
+testObjectMirror(this, 'global', '', true);  // Global object has special properties
+testObjectMirror(this.__proto__, 'Object', '');
+testObjectMirror([], 'Array', 'Array');
+testObjectMirror([1,2], 'Array', 'Array');
+
+// Test circular references.
+o = {};
+o.o = o;
+testObjectMirror(o, 'Object', 'Object');
+
+// Test that non enumerable properties are part of the mirror
+global_mirror = debug.MakeMirror(this);
+assertEquals('property', global_mirror.property("Math").type());
+assertFalse(global_mirror.property("Math").isEnum(), "Math is enumerable" + global_mirror.property("Math").attributes());
+
+math_mirror = global_mirror.property("Math").value();
+assertEquals('property', math_mirror.property("E").type());
+assertFalse(math_mirror.property("E").isEnum(), "Math.E is enumerable");
+assertTrue(math_mirror.property("E").isReadOnly());
+assertFalse(math_mirror.property("E").canDelete());
+
+// Test objects with JavaScript accessors.
+o = {}
+o.__defineGetter__('a', function(){return 'a';});
+o.__defineSetter__('b', function(){});
+o.__defineGetter__('c', function(){throw 'c';});
+o.__defineSetter__('c', function(){throw 'c';});
+testObjectMirror(o, 'Object', 'Object');
+mirror = debug.MakeMirror(o);
+// a has getter but no setter.
+assertTrue(mirror.property('a').hasGetter());
+assertFalse(mirror.property('a').hasSetter());
+assertEquals(debug.PropertyType.Callbacks, mirror.property('a').propertyType());
+assertEquals('function', mirror.property('a').getter().type());
+assertEquals('undefined', mirror.property('a').setter().type());
+assertEquals('function (){return \'a\';}', mirror.property('a').getter().source());
+// b has setter but no getter.
+assertFalse(mirror.property('b').hasGetter());
+assertTrue(mirror.property('b').hasSetter());
+assertEquals(debug.PropertyType.Callbacks, mirror.property('b').propertyType());
+assertEquals('undefined', mirror.property('b').getter().type());
+assertEquals('function', mirror.property('b').setter().type());
+assertEquals('function (){}', mirror.property('b').setter().source());
+assertFalse(mirror.property('b').isException());
+// c has both getter and setter. The getter throws an exception.
+assertTrue(mirror.property('c').hasGetter());
+assertTrue(mirror.property('c').hasSetter());
+assertEquals(debug.PropertyType.Callbacks, mirror.property('c').propertyType());
+assertEquals('function', mirror.property('c').getter().type());
+assertEquals('function', mirror.property('c').setter().type());
+assertEquals('function (){throw \'c\';}', mirror.property('c').getter().source());
+assertEquals('function (){throw \'c\';}', mirror.property('c').setter().source());
+
+// Test objects with native accessors.
+mirror = debug.MakeMirror(new String('abc'));
+assertTrue(mirror instanceof debug.ObjectMirror);
+assertFalse(mirror.property('length').hasGetter());
+assertFalse(mirror.property('length').hasSetter());
+assertTrue(mirror.property('length').isNative());
+assertEquals('a', mirror.property(0).value().value());
+assertEquals('b', mirror.property(1).value().value());
+assertEquals('c', mirror.property(2).value().value());

data/ext/v8/upstream/2.0.6/test/mjsunit/mirror-regexp.js

@@ -0,0 +1,110 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --expose-debug-as debug
+// Test the mirror object for regular expression values
+
+var all_attributes = debug.PropertyAttribute.ReadOnly |
+                     debug.PropertyAttribute.DontEnum |
+                     debug.PropertyAttribute.DontDelete;
+var expected_attributes = {
+  'source': all_attributes,
+  'global': all_attributes,
+  'ignoreCase': all_attributes,
+  'multiline': all_attributes,
+  'lastIndex': debug.PropertyAttribute.DontEnum | debug.PropertyAttribute.DontDelete
+};
+
+function MirrorRefCache(json_refs) {
+  var tmp = eval('(' + json_refs + ')');
+  this.refs_ = [];
+  for (var i = 0; i < tmp.length; i++) {
+    this.refs_[tmp[i].handle] = tmp[i];
+  }
+}
+
+MirrorRefCache.prototype.lookup = function(handle) {
+  return this.refs_[handle];
+}
+
+function testRegExpMirror(r) {
+  // Create mirror and JSON representation.
+  var mirror = debug.MakeMirror(r);
+  var serializer = debug.MakeMirrorSerializer();
+  var json = JSON.stringify(serializer.serializeValue(mirror));
+  var refs = new MirrorRefCache(
+      JSON.stringify(serializer.serializeReferencedObjects()));
+
+  // Check the mirror hierachy.
+  assertTrue(mirror instanceof debug.Mirror);
+  assertTrue(mirror instanceof debug.ValueMirror);
+  assertTrue(mirror instanceof debug.ObjectMirror);
+  assertTrue(mirror instanceof debug.RegExpMirror);
+
+  // Check the mirror properties.
+  assertTrue(mirror.isRegExp());
+  assertEquals('regexp', mirror.type());
+  assertFalse(mirror.isPrimitive());
+  for (var p in expected_attributes) {
+    assertEquals(mirror.property(p).attributes(),
+                 expected_attributes[p],
+                 p + ' attributes');
+  }
+
+  // Test text representation
+  assertEquals('/' + r.source + '/', mirror.toText());
+
+  // Parse JSON representation and check.
+  var fromJSON = eval('(' + json + ')');
+  assertEquals('regexp', fromJSON.type);
+  assertEquals('RegExp', fromJSON.className);
+  for (var p in expected_attributes) {
+    for (var i = 0; i < fromJSON.properties.length; i++) {
+      if (fromJSON.properties[i].name == p) {
+        assertEquals(expected_attributes[p],
+                     fromJSON.properties[i].attributes,
+                     'Unexpected value for ' + p + ' attributes');
+        assertEquals(mirror.property(p).propertyType(),
+                     fromJSON.properties[i].propertyType,
+                     'Unexpected value for ' + p + ' propertyType');
+        assertEquals(mirror.property(p).value().handle(),
+                     fromJSON.properties[i].ref,
+                     'Unexpected handle for ' + p);
+        assertEquals(mirror.property(p).value().value(),
+                     refs.lookup(fromJSON.properties[i].ref).value,
+                     'Unexpected value for ' + p);
+      }
+    }
+  }
+}
+
+
+// Test Date values.
+testRegExpMirror(/x/);
+testRegExpMirror(/[abc]/);
+testRegExpMirror(/[\r\n]/g);
+testRegExpMirror(/a*b/gmi);

data/ext/v8/upstream/2.0.6/test/mjsunit/mirror-script.js

@@ -0,0 +1,100 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --expose-debug-as debug --allow-natives-syntax
+// Test the mirror object for scripts.
+
+function testScriptMirror(f, file_name, file_lines, type, compilation_type,
+                          source, eval_from_line) {
+  // Create mirror and JSON representation.
+  var mirror = debug.MakeMirror(f).script();
+  var serializer = debug.MakeMirrorSerializer();
+  var json = JSON.stringify(serializer.serializeValue(mirror));
+
+  // Check the mirror hierachy.
+  assertTrue(mirror instanceof debug.Mirror);
+  assertFalse(mirror instanceof debug.ValueMirror);
+  assertTrue(mirror instanceof debug.ScriptMirror);
+
+  // Check the mirror properties.
+  assertTrue(mirror.isScript());
+  assertEquals('script', mirror.type());
+  var name = mirror.name();
+  if (name) {
+    assertEquals(file_name, name.substring(name.length - file_name.length));
+  } else {
+    assertTrue(file_name === null);
+  }
+  assertEquals(0, mirror.lineOffset());
+  assertEquals(0, mirror.columnOffset());
+  if (file_lines > 0) {
+    assertEquals(file_lines, mirror.lineCount());
+  }
+  assertEquals(type, mirror.scriptType());
+  assertEquals(compilation_type, mirror.compilationType(), "compilation type");
+  if (source) {
+    assertEquals(source, mirror.source());
+  }
+  if (eval_from_line) {
+    assertEquals(eval_from_line,  mirror.evalFromLocation().line);
+  }
+  
+  // Parse JSON representation and check.
+  var fromJSON = JSON.parse(json);
+  assertEquals('script', fromJSON.type);
+  name = fromJSON.name;
+  if (name) {
+    assertEquals(file_name, name.substring(name.length - file_name.length));
+  } else {
+    assertTrue(file_name === null);
+  }
+  assertEquals(0, fromJSON.lineOffset);
+  assertEquals(0, fromJSON.columnOffset);
+  if (file_lines > 0) {
+    assertEquals(file_lines, fromJSON.lineCount);
+  }
+  assertEquals(type, fromJSON.scriptType);
+  assertEquals(compilation_type, fromJSON.compilationType);
+}
+
+
+// Test the script mirror for different functions.
+testScriptMirror(function(){}, 'mirror-script.js', 100, 2, 0);
+testScriptMirror(Math.sin, 'native math.js', -1, 0, 0);
+testScriptMirror(eval('(function(){})'), null, 1, 2, 1, '(function(){})', 87);
+testScriptMirror(eval('(function(){\n  })'), null, 2, 2, 1, '(function(){\n  })', 88);
+testScriptMirror(%CompileString("({a:1,b:2})", true), null, 1, 2, 2, '({a:1,b:2})');
+testScriptMirror(%CompileString("({a:1,\n  b:2})", true), null, 2, 2, 2, '({a:1,\n  b:2})');
+
+// Test taking slices of source.
+var mirror = debug.MakeMirror(eval('(function(){\n  1;\n})')).script();
+assertEquals('(function(){\n', mirror.sourceSlice(0, 1).sourceText());
+assertEquals('  1;\n', mirror.sourceSlice(1, 2).sourceText());
+assertEquals('})', mirror.sourceSlice(2, 3).sourceText());
+assertEquals('(function(){\n  1;\n', mirror.sourceSlice(0, 2).sourceText());
+assertEquals('  1;\n})', mirror.sourceSlice(1, 3).sourceText());
+assertEquals('(function(){\n  1;\n})', mirror.sourceSlice(0, 3).sourceText());

data/ext/v8/upstream/2.0.6/test/mjsunit/mirror-string.js

@@ -0,0 +1,89 @@
+// Copyright 2008 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --expose-debug-as debug
+// Test the mirror object for string values
+
+const kMaxProtocolStringLength = 80; // Constant from mirror-delay.js
+
+function testStringMirror(s) {
+  // Create mirror and JSON representation.
+  var mirror = debug.MakeMirror(s);
+  var serializer = debug.MakeMirrorSerializer();
+  var json = JSON.stringify(serializer.serializeValue(mirror));
+
+  // Check the mirror hierachy.
+  assertTrue(mirror instanceof debug.Mirror);
+  assertTrue(mirror instanceof debug.ValueMirror);
+  assertTrue(mirror instanceof debug.StringMirror);
+
+  // Check the mirror properties.
+  assertTrue(mirror.isString());
+  assertEquals('string', mirror.type());
+  assertTrue(mirror.isPrimitive());
+
+  // Test text representation
+  if (s.length <= kMaxProtocolStringLength) {
+    assertEquals(s, mirror.toText());
+  } else {
+    assertEquals(s.substring(0, kMaxProtocolStringLength),
+                 mirror.toText().substring(0, kMaxProtocolStringLength));
+  }
+
+  // Parse JSON representation and check.
+  var fromJSON = eval('(' + json + ')');
+  assertEquals('string', fromJSON.type);
+  if (s.length <= kMaxProtocolStringLength) {
+    assertEquals(s, fromJSON.value);
+  } else {
+    assertEquals(s.substring(0, kMaxProtocolStringLength),
+                 fromJSON.value.substring(0, kMaxProtocolStringLength));
+    assertEquals(fromJSON.fromIndex, 0);
+    assertEquals(fromJSON.toIndex, kMaxProtocolStringLength);
+  }
+}
+
+// Test a number of different strings.
+testStringMirror('');
+testStringMirror('abcdABCD');
+testStringMirror('1234');
+testStringMirror('"');
+testStringMirror('"""');
+testStringMirror("'");
+testStringMirror("'''");
+testStringMirror("'\"'");
+testStringMirror('\\');
+testStringMirror('\b\t\n\f\r');
+testStringMirror('\u0001\u0002\u001E\u001F');
+testStringMirror('"a":1,"b":2');
+
+var s = "1234567890"
+s = s + s + s + s + s + s + s + s;
+assertEquals(kMaxProtocolStringLength, s.length);
+testStringMirror(s);
+s = s + 'X';
+testStringMirror(s);