// Copyright 2013 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.

#include <stdlib.h>

#include "src/v8.h"
#include "test/cctest/cctest.h"

#include "src/api.h"
#include "src/heap/heap.h"
#include "src/objects.h"

using namespace v8::internal;

static Isolate* GetIsolateFrom(LocalContext* context) {
  return reinterpret_cast<Isolate*>((*context)->GetIsolate());
}


static int CountArrayBuffersInWeakList(Heap* heap) {
  int count = 0;
  for (Object* o = heap->array_buffers_list();
       !o->IsUndefined();
       o = JSArrayBuffer::cast(o)->weak_next()) {
    count++;
  }
  return count;
}


static bool HasArrayBufferInWeakList(Heap* heap, JSArrayBuffer* ab) {
  for (Object* o = heap->array_buffers_list();
       !o->IsUndefined();
       o = JSArrayBuffer::cast(o)->weak_next()) {
    if (ab == o) return true;
  }
  return false;
}


static int CountViews(JSArrayBuffer* array_buffer) {
  int count = 0;
  for (Object* o = array_buffer->weak_first_view();
       !o->IsUndefined();
       o = JSArrayBufferView::cast(o)->weak_next()) {
    count++;
  }

  return count;
}

static bool HasViewInWeakList(JSArrayBuffer* array_buffer,
                              JSArrayBufferView* ta) {
  for (Object* o = array_buffer->weak_first_view();
       !o->IsUndefined();
       o = JSArrayBufferView::cast(o)->weak_next()) {
    if (ta == o) return true;
  }
  return false;
}


TEST(WeakArrayBuffersFromApi) {
  v8::V8::Initialize();
  LocalContext context;
  Isolate* isolate = GetIsolateFrom(&context);

  int start = CountArrayBuffersInWeakList(isolate->heap());
  {
    v8::HandleScope s1(context->GetIsolate());
    v8::Handle<v8::ArrayBuffer> ab1 =
        v8::ArrayBuffer::New(context->GetIsolate(), 256);
    {
      v8::HandleScope s2(context->GetIsolate());
      v8::Handle<v8::ArrayBuffer> ab2 =
          v8::ArrayBuffer::New(context->GetIsolate(), 128);

      Handle<JSArrayBuffer> iab1 = v8::Utils::OpenHandle(*ab1);
      Handle<JSArrayBuffer> iab2 = v8::Utils::OpenHandle(*ab2);
      CHECK_EQ(2, CountArrayBuffersInWeakList(isolate->heap()) - start);
      CHECK(HasArrayBufferInWeakList(isolate->heap(), *iab1));
      CHECK(HasArrayBufferInWeakList(isolate->heap(), *iab2));
    }
    isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
    CHECK_EQ(1, CountArrayBuffersInWeakList(isolate->heap()) - start);
    {
      HandleScope scope2(isolate);
      Handle<JSArrayBuffer> iab1 = v8::Utils::OpenHandle(*ab1);

      CHECK(HasArrayBufferInWeakList(isolate->heap(), *iab1));
    }
  }

  isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
  CHECK_EQ(start, CountArrayBuffersInWeakList(isolate->heap()));
}


TEST(WeakArrayBuffersFromScript) {
  v8::V8::Initialize();
  LocalContext context;
  Isolate* isolate = GetIsolateFrom(&context);
  int start = CountArrayBuffersInWeakList(isolate->heap());

  for (int i = 1; i <= 3; i++) {
    // Create 3 array buffers, make i-th of them garbage,
    // validate correct state of array buffer weak list.
    CHECK_EQ(start, CountArrayBuffersInWeakList(isolate->heap()));
    {
      v8::HandleScope scope(context->GetIsolate());

      {
        v8::HandleScope s1(context->GetIsolate());
        CompileRun("var ab1 = new ArrayBuffer(256);"
                   "var ab2 = new ArrayBuffer(256);"
                   "var ab3 = new ArrayBuffer(256);");
        v8::Handle<v8::ArrayBuffer> ab1 =
            v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab1"));
        v8::Handle<v8::ArrayBuffer> ab2 =
            v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab2"));
        v8::Handle<v8::ArrayBuffer> ab3 =
            v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab3"));

        CHECK_EQ(3, CountArrayBuffersInWeakList(isolate->heap()) - start);
        CHECK(HasArrayBufferInWeakList(isolate->heap(),
              *v8::Utils::OpenHandle(*ab1)));
        CHECK(HasArrayBufferInWeakList(isolate->heap(),
              *v8::Utils::OpenHandle(*ab2)));
        CHECK(HasArrayBufferInWeakList(isolate->heap(),
              *v8::Utils::OpenHandle(*ab3)));
      }

      i::ScopedVector<char> source(1024);
      i::SNPrintF(source, "ab%d = null;", i);
      CompileRun(source.start());
      isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

      CHECK_EQ(2, CountArrayBuffersInWeakList(isolate->heap()) - start);

      {
        v8::HandleScope s2(context->GetIsolate());
        for (int j = 1; j <= 3; j++) {
          if (j == i) continue;
          i::SNPrintF(source, "ab%d", j);
          v8::Handle<v8::ArrayBuffer> ab =
              v8::Handle<v8::ArrayBuffer>::Cast(CompileRun(source.start()));
          CHECK(HasArrayBufferInWeakList(isolate->heap(),
                *v8::Utils::OpenHandle(*ab)));
          }
      }

      CompileRun("ab1 = null; ab2 = null; ab3 = null;");
    }

    isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
    CHECK_EQ(start, CountArrayBuffersInWeakList(isolate->heap()));
  }
}

template <typename View>
void TestViewFromApi() {
  v8::V8::Initialize();
  LocalContext context;
  Isolate* isolate = GetIsolateFrom(&context);

  v8::HandleScope s1(context->GetIsolate());
  v8::Handle<v8::ArrayBuffer> ab =
      v8::ArrayBuffer::New(context->GetIsolate(), 2048);
  Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
  {
    v8::HandleScope s2(context->GetIsolate());
    v8::Handle<View> ta1 = View::New(ab, 0, 256);
    {
      v8::HandleScope s3(context->GetIsolate());
      v8::Handle<View> ta2 = View::New(ab, 0, 128);

      Handle<JSArrayBufferView> ita1 = v8::Utils::OpenHandle(*ta1);
      Handle<JSArrayBufferView> ita2 = v8::Utils::OpenHandle(*ta2);
      CHECK_EQ(2, CountViews(*iab));
      CHECK(HasViewInWeakList(*iab, *ita1));
      CHECK(HasViewInWeakList(*iab, *ita2));
    }
    isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
    CHECK_EQ(1, CountViews(*iab));
    Handle<JSArrayBufferView> ita1 = v8::Utils::OpenHandle(*ta1);
    CHECK(HasViewInWeakList(*iab, *ita1));
  }
  isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

  CHECK_EQ(0, CountViews(*iab));
}


TEST(Uint8ArrayFromApi) {
  TestViewFromApi<v8::Uint8Array>();
}


TEST(Int8ArrayFromApi) {
  TestViewFromApi<v8::Int8Array>();
}


TEST(Uint16ArrayFromApi) {
  TestViewFromApi<v8::Uint16Array>();
}


TEST(Int16ArrayFromApi) {
  TestViewFromApi<v8::Int16Array>();
}


TEST(Uint32ArrayFromApi) {
  TestViewFromApi<v8::Uint32Array>();
}


TEST(Int32ArrayFromApi) {
  TestViewFromApi<v8::Int32Array>();
}


TEST(Float32ArrayFromApi) {
  TestViewFromApi<v8::Float32Array>();
}


TEST(Float64ArrayFromApi) {
  TestViewFromApi<v8::Float64Array>();
}


TEST(Uint8ClampedArrayFromApi) {
  TestViewFromApi<v8::Uint8ClampedArray>();
}


TEST(DataViewFromApi) {
  TestViewFromApi<v8::DataView>();
}

template <typename TypedArray>
static void TestTypedArrayFromScript(const char* constructor) {
  v8::V8::Initialize();
  LocalContext context;
  Isolate* isolate = GetIsolateFrom(&context);
  v8::HandleScope scope(context->GetIsolate());
  int start = CountArrayBuffersInWeakList(isolate->heap());
  CompileRun("var ab = new ArrayBuffer(2048);");
  for (int i = 1; i <= 3; i++) {
    // Create 3 typed arrays, make i-th of them garbage,
    // validate correct state of typed array weak list.
    v8::HandleScope s0(context->GetIsolate());
    i::ScopedVector<char> source(2048);

    CHECK_EQ(1, CountArrayBuffersInWeakList(isolate->heap()) - start);

    {
      v8::HandleScope s1(context->GetIsolate());
      i::SNPrintF(source,
              "var ta1 = new %s(ab);"
              "var ta2 = new %s(ab);"
              "var ta3 = new %s(ab)",
              constructor, constructor, constructor);

      CompileRun(source.start());
      v8::Handle<v8::ArrayBuffer> ab =
          v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab"));
      v8::Handle<TypedArray> ta1 =
          v8::Handle<TypedArray>::Cast(CompileRun("ta1"));
      v8::Handle<TypedArray> ta2 =
          v8::Handle<TypedArray>::Cast(CompileRun("ta2"));
      v8::Handle<TypedArray> ta3 =
          v8::Handle<TypedArray>::Cast(CompileRun("ta3"));
      CHECK_EQ(1, CountArrayBuffersInWeakList(isolate->heap()) - start);
      Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
      CHECK_EQ(3, CountViews(*iab));
      CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta1)));
      CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta2)));
      CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta3)));
    }

    i::SNPrintF(source, "ta%d = null;", i);
    CompileRun(source.start());
    isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

    CHECK_EQ(1, CountArrayBuffersInWeakList(isolate->heap()) - start);

    {
      v8::HandleScope s2(context->GetIsolate());
      v8::Handle<v8::ArrayBuffer> ab =
          v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab"));
      Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
      CHECK_EQ(2, CountViews(*iab));
      for (int j = 1; j <= 3; j++) {
        if (j == i) continue;
        i::SNPrintF(source, "ta%d", j);
        v8::Handle<TypedArray> ta =
            v8::Handle<TypedArray>::Cast(CompileRun(source.start()));
        CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta)));
      }
    }

    CompileRun("ta1 = null; ta2 = null; ta3 = null;");
    isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);

    CHECK_EQ(1, CountArrayBuffersInWeakList(isolate->heap()) - start);

    {
      v8::HandleScope s3(context->GetIsolate());
      v8::Handle<v8::ArrayBuffer> ab =
          v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab"));
      Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
      CHECK_EQ(0, CountViews(*iab));
    }
  }
}


TEST(Uint8ArrayFromScript) {
  TestTypedArrayFromScript<v8::Uint8Array>("Uint8Array");
}


TEST(Int8ArrayFromScript) {
  TestTypedArrayFromScript<v8::Int8Array>("Int8Array");
}


TEST(Uint16ArrayFromScript) {
  TestTypedArrayFromScript<v8::Uint16Array>("Uint16Array");
}


TEST(Int16ArrayFromScript) {
  TestTypedArrayFromScript<v8::Int16Array>("Int16Array");
}


TEST(Uint32ArrayFromScript) {
  TestTypedArrayFromScript<v8::Uint32Array>("Uint32Array");
}


TEST(Int32ArrayFromScript) {
  TestTypedArrayFromScript<v8::Int32Array>("Int32Array");
}


TEST(Float32ArrayFromScript) {
  TestTypedArrayFromScript<v8::Float32Array>("Float32Array");
}


TEST(Float64ArrayFromScript) {
  TestTypedArrayFromScript<v8::Float64Array>("Float64Array");
}


TEST(Uint8ClampedArrayFromScript) {
  TestTypedArrayFromScript<v8::Uint8ClampedArray>("Uint8ClampedArray");
}


TEST(DataViewFromScript) {
  TestTypedArrayFromScript<v8::DataView>("DataView");
}