Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
*/
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#include "ds/TraceableFifo.h"
#include "js/PropertyAndElement.h" // JS_DefineProperty, JS_GetProperty
#include "js/RootingAPI.h"
#include "jsapi-tests/tests.h"
using namespace js;
BEGIN_TEST(testTraceableFifoValueBasic) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Test empty state
CHECK(fifo.empty());
CHECK(fifo.length() == 0);
// Test pushBack with various JS::Value types
CHECK(fifo.pushBack(JS::UndefinedValue()));
CHECK(fifo.pushBack(JS::NullValue()));
CHECK(fifo.pushBack(JS::Int32Value(42)));
CHECK(fifo.pushBack(JS::BooleanValue(true)));
CHECK(fifo.pushBack(JS::DoubleValue(3.14)));
CHECK(!fifo.empty());
CHECK(fifo.length() == 5);
// Test FIFO behavior - first in, first out
CHECK(fifo.front().isUndefined());
fifo.popFront();
CHECK(fifo.front().isNull());
fifo.popFront();
CHECK(fifo.front().isInt32() && fifo.front().toInt32() == 42);
fifo.popFront();
CHECK(fifo.front().isBoolean() && fifo.front().toBoolean() == true);
fifo.popFront();
CHECK(fifo.front().isDouble() && fifo.front().toDouble() == 3.14);
fifo.popFront();
CHECK(fifo.empty());
CHECK(fifo.length() == 0);
return true;
}
END_TEST(testTraceableFifoValueBasic)
BEGIN_TEST(testTraceableFifoValueGCSurvival) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Create objects and add them to fifo
const size_t numObjects = 15;
for (size_t i = 0; i < numObjects; ++i) {
JS::RootedObject obj(cx, JS_NewPlainObject(cx));
CHECK(obj);
// Add a property to make objects identifiable
JS::RootedValue indexVal(cx, JS::NumberValue(static_cast<double>(i)));
CHECK(JS_DefineProperty(cx, obj, "testIndex", indexVal, 0));
JS::RootedValue objVal(cx, JS::ObjectValue(*obj));
CHECK(fifo.pushBack(objVal));
}
CHECK(fifo.length() == numObjects);
// Trigger multiple GC cycles to ensure objects are properly traced
JS_GC(cx);
JS_GC(cx);
JS_GC(cx);
// Verify all objects survived and have correct properties
for (size_t i = 0; i < numObjects; ++i) {
CHECK(!fifo.empty());
CHECK(fifo.front().isObject());
JS::RootedObject obj(cx, &fifo.front().toObject());
CHECK(obj);
JS::RootedValue indexVal(cx);
CHECK(JS_GetProperty(cx, obj, "testIndex", &indexVal));
CHECK(indexVal.isNumber() && indexVal.toNumber() == static_cast<double>(i));
fifo.popFront();
}
CHECK(fifo.empty());
return true;
}
END_TEST(testTraceableFifoValueGCSurvival)
BEGIN_TEST(testTraceableFifoValueStrings) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Test with various string types
const char* testStrings[] = {"hello",
"world",
"TraceableFifo",
"JavaScript",
"garbage collection",
"SpiderMonkey",
"test string with spaces"};
// Add strings to fifo
for (const char* str : testStrings) {
JS::RootedString jsStr(cx, JS_NewStringCopyZ(cx, str));
CHECK(jsStr);
JS::RootedValue strVal(cx, JS::StringValue(jsStr));
CHECK(fifo.pushBack(strVal));
}
CHECK(fifo.length() == std::size(testStrings));
// Trigger GC to ensure strings survive
JS_GC(cx);
// Verify strings in FIFO order
for (const char* expected : testStrings) {
CHECK(!fifo.empty());
CHECK(fifo.front().isString());
JS::RootedString str(cx, fifo.front().toString());
CHECK(str);
bool match = false;
CHECK(JS_StringEqualsAscii(cx, str, expected, strlen(expected), &match));
CHECK(match);
fifo.popFront();
}
CHECK(fifo.empty());
return true;
}
END_TEST(testTraceableFifoValueStrings)
BEGIN_TEST(testTraceableFifoValueMixed) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Mix different value types
CHECK(fifo.pushBack(JS::Int32Value(100)));
JS::RootedString str(cx, JS_NewStringCopyZ(cx, "mixed"));
CHECK(str);
CHECK(fifo.pushBack(JS::StringValue(str)));
JS::RootedObject obj(cx, JS_NewPlainObject(cx));
CHECK(obj);
CHECK(fifo.pushBack(JS::ObjectValue(*obj)));
CHECK(fifo.pushBack(JS::BooleanValue(false)));
CHECK(fifo.pushBack(JS::UndefinedValue()));
CHECK(fifo.length() == 5);
// Force GC between operations
JS_GC(cx);
// Verify mixed types maintain order and survive GC
CHECK(fifo.front().isInt32() && fifo.front().toInt32() == 100);
fifo.popFront();
CHECK(fifo.front().isString());
JS::RootedString retrievedStr(cx, fifo.front().toString());
bool match = false;
CHECK(JS_StringEqualsAscii(cx, retrievedStr, "mixed", 5, &match));
CHECK(match);
fifo.popFront();
CHECK(fifo.front().isObject());
CHECK(&fifo.front().toObject() == obj);
fifo.popFront();
CHECK(fifo.front().isBoolean() && !fifo.front().toBoolean());
fifo.popFront();
CHECK(fifo.front().isUndefined());
fifo.popFront();
CHECK(fifo.empty());
return true;
}
END_TEST(testTraceableFifoValueMixed)
BEGIN_TEST(testTraceableFifoValueEmplaceBack) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Test emplaceBack with different value construction
CHECK(fifo.emplaceBack(JS::UndefinedValue()));
CHECK(fifo.emplaceBack(JS::Int32Value(999)));
CHECK(fifo.emplaceBack(JS::DoubleValue(2.718)));
CHECK(fifo.length() == 3);
// Verify emplaced values
CHECK(fifo.front().isUndefined());
fifo.popFront();
CHECK(fifo.front().isInt32() && fifo.front().toInt32() == 999);
fifo.popFront();
CHECK(fifo.front().isDouble() && fifo.front().toDouble() == 2.718);
fifo.popFront();
CHECK(fifo.empty());
return true;
}
END_TEST(testTraceableFifoValueEmplaceBack)
BEGIN_TEST(testTraceableFifoValueClear) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Fill with many values
for (int i = 0; i < 30; ++i) {
if (i % 3 == 0) {
CHECK(fifo.pushBack(JS::Int32Value(i)));
} else if (i % 3 == 1) {
JS::RootedObject obj(cx, JS_NewPlainObject(cx));
CHECK(obj);
CHECK(fifo.pushBack(JS::ObjectValue(*obj)));
} else {
JS::RootedString str(cx, JS_NewStringCopyZ(cx, "test"));
CHECK(str);
CHECK(fifo.pushBack(JS::StringValue(str)));
}
}
CHECK(fifo.length() == 30);
CHECK(!fifo.empty());
// Clear the fifo
fifo.clear();
CHECK(fifo.length() == 0);
CHECK(fifo.empty());
// Verify we can still use it after clear
CHECK(fifo.pushBack(JS::Int32Value(42)));
CHECK(fifo.length() == 1);
CHECK(fifo.front().isInt32() && fifo.front().toInt32() == 42);
return true;
}
END_TEST(testTraceableFifoValueClear)
BEGIN_TEST(testTraceableFifoValueLargeScale) {
JS::Rooted<TraceableFifo<JS::Value>> fifo(cx, TraceableFifo<JS::Value>(cx));
// Large scale test with GC pressure
const size_t largeCount = 100;
for (size_t i = 0; i < largeCount; ++i) {
// Create different types of values
switch (i % 4) {
case 0: {
CHECK(fifo.pushBack(JS::Int32Value(static_cast<int32_t>(i))));
break;
}
case 1: {
JS::RootedObject obj(cx, JS_NewPlainObject(cx));
CHECK(obj);
CHECK(fifo.pushBack(JS::ObjectValue(*obj)));
break;
}
case 2: {
JS::RootedString str(cx, JS_NewStringCopyZ(cx, "large"));
CHECK(str);
CHECK(fifo.pushBack(JS::StringValue(str)));
break;
}
case 3: {
CHECK(fifo.pushBack(JS::DoubleValue(static_cast<double>(i) + 0.5)));
break;
}
}
// Periodic GC to test tracing under pressure
if (i % 25 == 0) {
JS_GC(cx);
}
}
CHECK(fifo.length() == largeCount);
// Final GC sweep
JS_GC(cx);
JS_GC(cx);
// Verify all values are intact
for (size_t i = 0; i < largeCount; ++i) {
CHECK(!fifo.empty());
switch (i % 4) {
case 0:
CHECK(fifo.front().isInt32());
CHECK(fifo.front().toInt32() == static_cast<int32_t>(i));
break;
case 1:
CHECK(fifo.front().isObject());
break;
case 2:
CHECK(fifo.front().isString());
break;
case 3:
CHECK(fifo.front().isDouble());
CHECK(fifo.front().toDouble() == static_cast<double>(i) + 0.5);
break;
}
fifo.popFront();
}
CHECK(fifo.empty());
return true;
}
END_TEST(testTraceableFifoValueLargeScale)