Quelle testMappedArrayBuffer.cpp Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
*/

#include <fcntl.h>
#include <stdio.h>

#include "js/Array.h"        // JS::NewArrayObject
#include "js/ArrayBuffer.h"  // JS::{{Create,Release}MappedArrayBufferContents,DetachArrayBuffer,GetArrayBuffer{ByteLength,Data},Is{,Detached,Mapped}ArrayBufferObject,NewMappedArrayBufferWithContents,StealArrayBufferContents}
#include "js/StructuredClone.h"
#include "jsapi-tests/tests.h"
#include "vm/ArrayBufferObject.h"

#ifdef XP_WIN
#  include <io.h>
#  define GET_OS_FD(a) int(_get_osfhandle(a))
#else
#  include <unistd.h>
#  define GET_OS_FD(a) (a)
#endif

const char test_data[] =
    "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
const char test_filename[] = "temp-bug945152_MappedArrayBuffer";

BEGIN_TEST(testMappedArrayBuffer_bug945152) {
  TempFile test_file;
  FILE* test_stream = test_file.open(test_filename);
  CHECK(fputs(test_data, test_stream) != EOF);
  test_file.close();

  // Offset 0.
  CHECK(TestCreateObject(0, 12));

  // Aligned offset.
  CHECK(TestCreateObject(8, 12));

  // Unaligned offset.
  CHECK(CreateNewObject(11, 12) == nullptr);

  // Offset + length greater than file size.
  CHECK(CreateNewObject(8, sizeof(test_data) - 7) == nullptr);

  // Release the mapped content.
  CHECK(TestReleaseContents());

  // Detach mapped array buffer.
  CHECK(TestDetachObject());

  // Clone mapped array buffer.
  CHECK(TestCloneObject());

  // Steal mapped array buffer contents.
  CHECK(TestStealContents());

  // Transfer mapped array buffer contents.
  CHECK(TestTransferObject());

  // GC so we can remove the file we created.
  GC(cx);

  test_file.remove();

  return true;
}

JSObject* CreateNewObject(const int offset, const int length) {
  int fd = open(test_filename, O_RDONLY);
  void* ptr =
      JS::CreateMappedArrayBufferContents(GET_OS_FD(fd), offset, length);
  close(fd);
  if (!ptr) {
    return nullptr;
  }
  JSObject* obj = JS::NewMappedArrayBufferWithContents(cx, length, ptr);
  if (!obj) {
    JS::ReleaseMappedArrayBufferContents(ptr, length);
    return nullptr;
  }
  return obj;
}

bool VerifyObject(JS::HandleObject obj, uint32_t offset, uint32_t length,
                  const bool mapped) {
  JS::AutoCheckCannotGC nogc;

  CHECK(obj);
  CHECK(JS::IsArrayBufferObject(obj));
  CHECK_EQUAL(JS::GetArrayBufferByteLength(obj), length);
  if (mapped) {
    CHECK(JS::IsMappedArrayBufferObject(obj));
  } else {
    CHECK(!JS::IsMappedArrayBufferObject(obj));
  }
  bool sharedDummy;
  const char* data = reinterpret_cast<const char*>(
      JS::GetArrayBufferData(obj, &sharedDummy, nogc));
  CHECK(data);
  CHECK(memcmp(data, test_data + offset, length) == 0);

  return true;
}

bool TestCreateObject(uint32_t offset, uint32_t length) {
  JS::RootedObject obj(cx, CreateNewObject(offset, length));
  CHECK(VerifyObject(obj, offset, length, true));

  return true;
}

bool TestReleaseContents() {
  int fd = open(test_filename, O_RDONLY);
  void* ptr = JS::CreateMappedArrayBufferContents(GET_OS_FD(fd), 0, 12);
  close(fd);
  if (!ptr) {
    return false;
  }
  JS::ReleaseMappedArrayBufferContents(ptr, 12);

  return true;
}

bool TestDetachObject() {
  JS::RootedObject obj(cx, CreateNewObject(8, 12));
  CHECK(obj);
  JS::DetachArrayBuffer(cx, obj);
  CHECK(JS::IsDetachedArrayBufferObject(obj));

  return true;
}

bool TestCloneObject() {
  JS::RootedObject obj1(cx, CreateNewObject(8, 12));
  CHECK(obj1);
  JSAutoStructuredCloneBuffer cloned_buffer(
      JS::StructuredCloneScope::SameProcess, nullptr, nullptr);
  JS::RootedValue v1(cx, JS::ObjectValue(*obj1));
  CHECK(cloned_buffer.write(cx, v1, nullptr, nullptr));
  JS::RootedValue v2(cx);
  CHECK(cloned_buffer.read(cx, &v2, JS::CloneDataPolicy(), nullptr, nullptr));
  JS::RootedObject obj2(cx, v2.toObjectOrNull());
  CHECK(VerifyObject(obj2, 8, 12, false));

  return true;
}

bool TestStealContents() {
  JS::RootedObject obj(cx, CreateNewObject(8, 12));
  CHECK(obj);
  void* contents = JS::StealArrayBufferContents(cx, obj);
  CHECK(contents);
  CHECK(memcmp(contents, test_data + 8, 12) == 0);
  CHECK(JS::IsDetachedArrayBufferObject(obj));

  return true;
}

bool TestTransferObject() {
  JS::RootedObject obj1(cx, CreateNewObject(8, 12));
  CHECK(obj1);
  JS::RootedValue v1(cx, JS::ObjectValue(*obj1));

  // Create an Array of transferable values.
  JS::RootedValueVector argv(cx);
  if (!argv.append(v1)) {
    return false;
  }

  JS::RootedObject obj(
      cx, JS::NewArrayObject(cx, JS::HandleValueArray::subarray(argv, 0, 1)));
  CHECK(obj);
  JS::RootedValue transferable(cx, JS::ObjectValue(*obj));

  JSAutoStructuredCloneBuffer cloned_buffer(
      JS::StructuredCloneScope::SameProcess, nullptr, nullptr);
  JS::CloneDataPolicy policy;
  CHECK(cloned_buffer.write(cx, v1, transferable, policy, nullptr, nullptr));
  JS::RootedValue v2(cx);
  CHECK(cloned_buffer.read(cx, &v2, policy, nullptr, nullptr));
  JS::RootedObject obj2(cx, v2.toObjectOrNull());
  CHECK(VerifyObject(obj2, 8, 12, true));
  CHECK(JS::IsDetachedArrayBufferObject(obj1));

  return true;
}

static void GC(JSContext* cx) {
  JS_GC(cx);
  // Trigger another to wait for background finalization to end.
  JS_GC(cx);
}

END_TEST(testMappedArrayBuffer_bug945152)

#undef GET_OS_FD

quality100%

¤ Dauer der Verarbeitung: 0.24 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.