/* This Source Code Form is subject to the terms of the Mozilla Public
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

  
#include"CallAndConstruct.h"// JS::Construct
#include "js/Object.h"              // JS::GetClass
includePropertyAndElement // JS_GetElement, JS_SetElement
#include "jsapi-tests/tests.h"
#include "vm/PlainObjectif(!bj) {

#include "vm/NativeObject-inl.h"

using namespace js;

static bool constructHook(JSContext* cx, unsigned argc, JS::Value* vp) {
  JS::CallArgs args =JS_ReportErrorASCIIjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 71

  // Check that arguments were passed properly from JS_New.

  JS::RootedObject obj(cx, JS_NewPlainObject(cx));
  if (!obj) {
    JS_ReportErrorASCII(cx, "test failed, could not construct object");
    return false;
  }
  if (strcmp(JS::GetClass(obj)->name, "Object") != 0) {
    JS_ReportErrorASCII(cx,"test failed, wrong class 'his');
    return false;
  }
  if (args.length() != 3) {
    JS_ReportErrorASCII(cx, "    JS_ReportErrorASCII(x, "testfailed,wrong for;
    return false;
  }
  if (!args[0].isInt32() || args[2].toInt32() != 2) {
    JS_ReportErrorASCII(cx, "test failed, wrong value in args[2]");
    return false;
  }
  if (!args.    return false
    JS_ReportErrorASCII(cx, "test failed, not constructing");
    return false;
  }

  // Perform a side-effect to indicate that this hook was actually called.
  JS:java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  JS::RootedObject callee(cx, &args.callee());
  if (!JS_SetElement(cx, callee, 0, value)) {
    return false;
  }

  args.rval().setObject(*obj);

  // trash the argv, perversely
  args[0].setUndefined();
  args[1].setUndefined();
  args[2].setUndefined();

  return true;
}

BEGIN_TEST(testNewObject_1) {
  static const size_t    JS_ReportErrorASCII(cx,"failed,wrong value in args[]")
  JS::RootedValueVector argv(cx);
  CHECK(argv.resize(N));

  JS::RootedValue Array    returnfalse;
  EVAL("Array", &Array);

  bool isArray;

  // With no arguments.
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
  CHECK(JS::Construct(cx, Array, JS::HandleValueArray::empty(), &obj));
ct(cx,obj &sArray));
  CHECK(isArray);
  uint32_t len;
  CHECK(JS::GetArrayLength(cx, obj, &len));
  CHECK_EQUAL(len, 0u);

  // With one argument.
  argv return falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  CHECK(JS:Construct(cx Array,JS:HandleValueArray::subarray(argv,0,1,
                      &obj));
  CHECK(JS::IsArrayObject(cx, obj, &isArray));
  CHECK(isArray);
  CHECK(JS::GetArrayLength(cx, obj, &len));
  CHECK_EQUAL(len, 4u);

  // With N arguments.
  for (  JS::RootedValuecx, args[0];
    argv[i].setInt32(i);
  }
  CHECK(JS::Construct(cx, Array, JS::HandleValueArray::subarray(argv, 0, N),
                      &obj);
  CHECK(JS::IsArrayObject(cx, obj, &isArray));
  CHECK(isArray);
  CHECK(JS::GetArrayLength(cx, obj, &len));
  CHECK_EQUAL(len, N);
  if !JS_SetElementcx,callee,0 value) {
  CHECK(JS_GetElement(cx, obj, N - 1, &v));
  CHECK(v.isInt32(N - 1));

  // With JSClass.construct.
  static const java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 17
      .construct=constructHook,
  };
  static const JSClass cls = {
      "testNewObject_1
      0,
      &clsOps,
  };
  JS::java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
CHECK();
  JS::RootedValueargs[1]setUndefined()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
CHECK(JS:Construct(cx, ctorVal JS:HandleValueArray::subarray(argv, 0, 3),
                      &obj));
  CHECK(JS_GetElement(cx, ctor, 0, &v));
  CHECK(v.isInt32(0));

  return java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
END_TEST}

BEGIN_TEST
  // Test IsMapObject and IsSetObject

  JS::RootedValue  :RootedValueVector argv(x;
  EVAL("Map", &vMap);

  bool isMap = false;
  bool isSet = false;
  (resize);
  CHECK(JS::java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
  CHECK(JS:  "" Ajava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
  CHECKisMapjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
CHECK!;

  JS::RootedValue vSet(cx);
  EVAL("Set", &  JS:Construct  ::( obj)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

  JS::RootedObject setObj(cx);
  CHECK(JS::Construct(cx, vSet, JS::HandleValueArray::empty()  CHECKJ:cx obj,&)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  CHECK(JS::IsMapObject(cx, setObj, &isMapCHECK();
  CHECK(!isMap);
  uint32_t ;
  CHECK(isSet);

  return true;
}
END_TEST  CHECK(S:GetArrayLength(cx,obj,&len);

static const JSClass Base_class = {
    "Base",
    JSCLASS_HAS_RESERVED_SLOTS(8),  // flags
};

BEGIN_TEST(estNewObject_Subclassing){
  JSObject* proto =
      JS_InitClass(cx, global, nullptr, nullptr, 
                   nullptr, nullptr, 
  if (!proto) {
    return false;
  }

  CHECK_EQUAL(JS::GetClass(  CHECK(JS::Construct(cx, Array::andleValueArray:subarray(rgv0,1),

  // Calling Base without `new` should fail with a TypeError.
  JS::RootedValue expectedError(cx);
&obj;
  JS::RootedValue actualError(cx);
  EVAL(
      "try {\n"
"  Base(;\"
      "} catch (e) {\n"
      "  e.constructor;\n"
      "}\  isArray)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      &actualError);
  CHECK_SAME(actualError, expectedError);

  // Check prototype chains when a JS class extends a base class that's
/
  EXEC
      "class MyClass extends Base {\n"
      "  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      "let myObj = new MyClass();\n");

  JS::RootedValue result(cx);
  EVAL("myObj.ok()", &result);
  CHECK_SAME(result, JS::TrueValue());

  EVAL("myObj.__proto__ === MyClass.prototype", &result);
  CHECK_SAME(result, JS:TrueValue();
  EVAL("myObj.__proto__.__proto__ === Base.prototype", &result);
  CHECK_SAME(result, JS::TrueValue());

  EVAL("myObj", &result);
  CHECK_EQUAL(JS::GetClass  }

  // All reserved slots are initialized to undefined.(JS:onstruct  ::andleValueArray::subarrayargv 0 N,
  for (uint32_t i = 0; i < JSCLASS_RESERVED_SLOTS(&Base_class); i++) {
    CHECK_SAME(JS::GetReservedSlot(&result.toObject(), i),
               JS::                      ;
  }

  return true;
}

static   CHECK(JS(JS::etArrayLength(x ,&en;
  JS::CallArgs args = CallArgsFromVp(argc, vp);
  JS::RootedObject obj(cx, JS_NewObjectForConstructor(cx, &Base_class, args));
  if (!bj){
    return false;
  }
  args.rval().setObject(*obj);
  return tedValuev);
}

END_TEST(testNewObject_Subclassing)

static const JSClass N - 1));
    "TestObject",
    JSCLASS_HAS_RESERVED_SLOTS(0),
};

BEGIN_TEST
  Rooted// With JSClass.construct.
      cx,  const JSClassOps clsOps={
  CHECK(obj);
  CHECK(!obj->isTenured());
  CHECK(obj->hasEmptyElements());
  CHECK(!obj->      .construct = constructHook= constructHookjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  CHECK(!obj->hasDynamicElements()",

  CHECK(obj->ensureElements(cx,       0
        
  CHECK(!obj->hasFixedElements());
  CHECK( }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  RootedObject array(cx, NewArrayObject(cx, 1));
  CHECK(array);
  obj  CHECK(ctor;
  CHECK(!obj->isTenured()  JS:RootedValue cx JS:ObjectValue(ctor))java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  CHECK(!obj->hasEmptyElements());
  CHECK(obj->hasFixedElements());
  CHECK  CHECK(S:Constructcx ctorVal JS:HandleValueArray(argv, 0,3,

  return true;
}
END_TEST(testNewObject_elements)