// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "emugl/common/thread_store.h"

#include "emugl/common/mutex.h"
#include "emugl/common/testing/test_thread.h"

#include <gtest/gtest.h>

namespace emugl {

namespace {

// Helper class used to count instance creation and destruction.
class StaticCounter {
public:
    enum {
        kMaxInstances = 1000,
    };

    StaticCounter() {
        Mutex::AutoLock lock(mMutex);
        if (mCreationCount < kMaxInstances)
            mInstances[mCreationCount] = this;
        mCreationCount++;
    }

    ~StaticCounter() {
        Mutex::AutoLock lock(mMutex);
        mDestructionCount++;
    }

    static void reset() {
        Mutex::AutoLock lock(mMutex);
        mCreationCount = 0;
        mDestructionCount = 0;
    }

    static size_t getCreationCount() {
        Mutex::AutoLock lock(mMutex);
        return mCreationCount;
    }

    static size_t getDestructionCount() {
        Mutex::AutoLock lock(mMutex);
        return mDestructionCount;
    }

    static void freeAll() {
        for (size_t n = 0; n < kMaxInstances; ++n)
            delete mInstances[n];
    }

private:
    static Mutex mMutex;
    static size_t mCreationCount;
    static size_t mDestructionCount;
    static StaticCounter* mInstances[kMaxInstances];
};

Mutex StaticCounter::mMutex;
size_t StaticCounter::mCreationCount = 0;
size_t StaticCounter::mDestructionCount = 0;
StaticCounter* StaticCounter::mInstances[kMaxInstances];

}  // namespace

// Just check that we can create a new ThreadStore with an empty
// destructor, and use it in the current thread.
TEST(ThreadStore, MainThreadWithoutDestructor) {
    ThreadStore store(NULL);
    static int x = 42;
    store.set(&x);
    EXPECT_EQ(&x, store.get());
}

// The following test checks that exiting a thread correctly deletes
// any thread-local value stored in it.
static void simplyDestroy(void* value) {
    delete (StaticCounter*) value;
}

static void* simpleThreadFunc(void* param) {
    ThreadStore* store = static_cast<ThreadStore*>(param);
    store->set(new StaticCounter());
    ThreadStore::OnThreadExit();
    return NULL;
}

TEST(ThreadStore, ThreadsWithDestructor) {
    ThreadStore store(simplyDestroy);
    const size_t kNumThreads = 1000;
    TestThread* threads[kNumThreads];
    StaticCounter::reset();

    for (size_t n = 0; n < kNumThreads; ++n) {
        threads[n] = new TestThread(&simpleThreadFunc, &store);
    }
    for (size_t n = 0; n < kNumThreads; ++n) {
        threads[n]->join();
    }

    EXPECT_EQ(kNumThreads, StaticCounter::getCreationCount());
    EXPECT_EQ(kNumThreads, StaticCounter::getDestructionCount());

    for (size_t n = 0; n < kNumThreads; ++n) {
        delete threads[n];
    }
}

TEST(ThreadStore, ThreadsWithoutDestructor) {
    ThreadStore store(NULL);
    const size_t kNumThreads = 1000;
    TestThread* threads[kNumThreads];
    StaticCounter::reset();

    for (size_t n = 0; n < kNumThreads; ++n) {
        threads[n] = new TestThread(&simpleThreadFunc, &store);
    }
    for (size_t n = 0; n < kNumThreads; ++n) {
        threads[n]->join();
    }

    EXPECT_EQ(kNumThreads, StaticCounter::getCreationCount());
    EXPECT_EQ(0U, StaticCounter::getDestructionCount());

    StaticCounter::freeAll();

    for (size_t n = 0; n < kNumThreads; ++n) {
        delete threads[n];
    }
}

}  // namespace emugl