Enhancements to PartitionAlloc to support threading and arbitrary allocation sizes.

Source/wtf/SpinLockTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 11 matching lines @@
  * 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 "config.h"
+#include "wtf/SpinLock.h"
 
-#include "weborigin/KURL.h"
-#include "weborigin/SecurityOrigin.h"
-#include "wtf/testing/WTFTestHelpers.h"
-
+#include "wtf/Threading.h"
 #include <gtest/gtest.h>
 
-using WebCore::SecurityOrigin;
-
 namespace {
 
-const int MaxAllowedPort = 65535;
+static const size_t bufferSize = 16;
 
-TEST(SecurityOriginTest, InvalidPortsCreateUniqueOrigins)
+static int lock = 0;
+
+static void fillBuffer(volatile char* buffer, char fillPattern)
 {
-    int ports[] = { -100, -1, MaxAllowedPort + 1, 1000000 };
+    for (int i = 0; i < bufferSize; ++i)
+        buffer[i] = fillPattern;
+}
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(ports); ++i) {
-        RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
-        EXPECT_TRUE(origin->isUnique()) << "Port " << ports[i] << " should have generated a unique origin.";
+static void changeAndCheckBuffer(volatile char* buffer)
+{
+    fillBuffer(buffer, '\0');
+    int total = 0;
+    for (int i = 0; i < bufferSize; ++i)
+        total += buffer[i];
+
+    EXPECT_EQ(0, total);
+
+    // This will mess with the other thread's calculation if we accidentally get
+    // concurrency.
+    fillBuffer(buffer, '!');
+}
+
+static void threadMain(void* arg)
+{
+    volatile char* buffer = reinterpret_cast<volatile char*>(arg);
+    for (int i = 0; i < 500000; ++i) {
+        spinLockLock(&lock);
+        changeAndCheckBuffer(buffer);
+        spinLockUnlock(&lock);
     }
 }
 
-TEST(SecurityOriginTest, ValidPortsCreateNonUniqueOrigins)
+TEST(WTF_SpinLock, Torture)
 {
-    int ports[] = { 0, 80, 443, 5000, MaxAllowedPort };
+    char sharedBuffer[bufferSize];
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(ports); ++i) {
-        RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
-        EXPECT_FALSE(origin->isUnique()) << "Port " << ports[i] << " should not have generated a unique origin.";
-    }
+    ThreadIdentifier thread1 = createThread(threadMain, sharedBuffer, "thread1");
+    ThreadIdentifier thread2 = createThread(threadMain, sharedBuffer, "thread2");
+    EXPECT_NE(0, thread1);
+    EXPECT_NE(0, thread2);
+
+    int ret = waitForThreadCompletion(thread1);
+    EXPECT_EQ(0, ret);
+    ret = waitForThreadCompletion(thread2);
+    EXPECT_EQ(0, ret);
 }
 
 } // namespace
-