// Generated from ST_avmplus_basics.st, ST_avmplus_builtins.st, ST_avmplus_peephole.st, ST_avmplus_vector_accessors.st, ST_mmgc_543560.st, ST_mmgc_575631.st, ST_mmgc_580603.st, ST_mmgc_603411.st, ST_mmgc_637993.st, ST_mmgc_basics.st, ST_mmgc_dependent.st, ST_mmgc_exact.st, ST_mmgc_externalalloc.st, ST_mmgc_finalize_uninit.st, ST_mmgc_fixedmalloc_findbeginning.st, ST_mmgc_gcheap.st, ST_mmgc_gcoption.st, ST_mmgc_mmfx_array.st, ST_mmgc_threads.st, ST_mmgc_weakref.st, ST_nanojit_codealloc.st, ST_vmbase_concurrency.st, ST_vmbase_safepoints.st, ST_vmpi_threads.st, ST_workers_Buffer.st, ST_workers_NoSyncSingleItemBuffer.st, ST_workers_Promise.st
// Generated from ST_avmplus_basics.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_avmplus_basics {
class ST_avmplus_basics : public Selftest {
public:
ST_avmplus_basics(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
};
ST_avmplus_basics::ST_avmplus_basics(AvmCore* core)
    : Selftest(core, "avmplus", "basics", ST_avmplus_basics::ST_names,ST_avmplus_basics::ST_explicits)
{}
const char* ST_avmplus_basics::ST_names[] = {"unsigned_int","signed_int","equalsLatin1","containsLatin1","indexOfLatin1","matchesLatin1","matchesLatin1_caseless","bug562101", NULL };
const bool ST_avmplus_basics::ST_explicits[] = {false,false,false,false,false,false,false,false, false };
void ST_avmplus_basics::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
case 5: test5(); return;
case 6: test6(); return;
case 7: test7(); return;
}
}
void ST_avmplus_basics::test0() {

// Does right shift of unsigned quantities work?
// line 14 "ST_avmplus_basics.st"
verifyPass((int)(~0U >> 1) > 0, "(int)(~0U >> 1) > 0", __FILE__, __LINE__);

}
void ST_avmplus_basics::test1() {

// Does right shift of signed quantities work?
// line 19 "ST_avmplus_basics.st"
verifyPass((-1 >> 1) == -1, "(-1 >> 1) == -1", __FILE__, __LINE__);

// verify that the "latin1" literal string calls work properly for hi-bit latin1 chars
}
void ST_avmplus_basics::test2() {
    Stringp s = core->newConstantStringLatin1("ev\xADident");
    bool equals = s->equalsLatin1("ev\xADident");
// line 25 "ST_avmplus_basics.st"
verifyPass(equals == true, "equals == true", __FILE__, __LINE__);

}
void ST_avmplus_basics::test3() {
    Stringp s = core->newConstantStringLatin1("ev\xADident");
    bool found = s->containsLatin1("\xAD");
// line 30 "ST_avmplus_basics.st"
verifyPass(found == true, "found == true", __FILE__, __LINE__);

}
void ST_avmplus_basics::test4() {
    Stringp s = core->newConstantStringLatin1("ev\xADident");
    int index = s->indexOfLatin1("\xAD");
// line 35 "ST_avmplus_basics.st"
verifyPass(index == 2, "index == 2", __FILE__, __LINE__);

}
void ST_avmplus_basics::test5() {
    Stringp s = core->newConstantStringLatin1("ev\xADident");
    bool matches1 = s->matchesLatin1("\xADi", 2, 2);
// line 40 "ST_avmplus_basics.st"
verifyPass(matches1 == true, "matches1 == true", __FILE__, __LINE__);

}
void ST_avmplus_basics::test6() {
    Stringp s = core->newConstantStringLatin1("ev\xADident");
    bool matches2 = s->matchesLatin1_caseless("\xADIDENT", 2, 2);
// line 45 "ST_avmplus_basics.st"
verifyPass(matches2 == true, "matches2 == true", __FILE__, __LINE__);


}
void ST_avmplus_basics::test7() {
// XMLParser omits the last char of a DOCTYPE node
Stringp str = core->newConstantStringLatin1("<?xml version=\"1.0\"?><!DOCTYPE greeting SYSTEM><greeting>Hello, world!</greeting>");
XMLParser parser(core, str);
MMgc::GC *gc = core->GetGC();
XMLTag tag(gc);
int m_status;
bool pass = false;
while ((m_status = parser.getNext(tag)) == XMLParser::kNoError)
{
    switch (tag.nodeType)
    {
        case XMLTag::kDocTypeDeclaration:
        {
            pass = false;
            pass = tag.text->equalsLatin1("<!DOCTYPE greeting SYSTEM>");
        }
    break;
    }
}
// line 68 "ST_avmplus_basics.st"
verifyPass(pass == true, "pass == true", __FILE__, __LINE__);

    // FIXME: this needs a "register this object with the GC" mechanism; this abuse of the GCRoot mechanism
    // is no longer allowed
//%%test bug610022
//    Stringp str = core->newConstantStringLatin1("some string that is likely to be unique");
//    WeakRefList<String> list(core->GetGC(), 0);
    // We are going to skip scanning the stack (so that "str" won't hold the string in place)
    // but that means we need a root to ensure that "list" doesn't also get collected.
    //
    //MMgc::GCRoot root(core->GetGC(), &list, sizeof(list));
    //list.add(str);
    //str = NULL;
    //core->GetGC()->Collect(/*scanStack*/false);
    //int removed = list.removeCollectedItems();
    //int count = list.length();
//%%verify removed == 1 && count == 0



}
void create_avmplus_basics(AvmCore* core) { new ST_avmplus_basics(core); }
}
}
#endif

// Generated from ST_avmplus_builtins.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_avmplus_builtins {
class ST_avmplus_builtins : public Selftest {
public:
ST_avmplus_builtins(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
};
ST_avmplus_builtins::ST_avmplus_builtins(AvmCore* core)
    : Selftest(core, "avmplus", "builtins", ST_avmplus_builtins::ST_names,ST_avmplus_builtins::ST_explicits)
{}
const char* ST_avmplus_builtins::ST_names[] = {"WeakValueHashTable", NULL };
const bool ST_avmplus_builtins::ST_explicits[] = {false, false };
void ST_avmplus_builtins::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_avmplus_builtins::test0() {
    WeakValueHashtable* tbl = WeakValueHashtable::create(core->gc);
    String* fhtagn = String::createLatin1(core, "Fhtagn!");
    MMgc::GCObjectLock* fhtagn_lock = core->gc->LockObject(fhtagn);
    fhtagn = NULL;
    for ( int i=0 ; i < 500 ; i++ ) {
        tbl->add(atomFromIntptrValue(i), (i & 1) ? String::createLatin1(core, "Cthulhu!")->atom() : ((String*)core->gc->GetLockedObject(fhtagn_lock))->atom());
    }
    core->gc->Collect();
    core->gc->Collect();
    int sum = 0;
    for ( int i=0 ; i < 500 ; i++ ) {
        Atom a = tbl->get(atomFromIntptrValue(i));
        if (a != AtomConstants::undefinedAtom)
            sum++;
    }
    core->gc->UnlockObject(fhtagn_lock);
    printf("fhtagn sum: %d\n", sum);

// Retain at least 250, but it would be unreasonable to retain more than 300
// line 31 "ST_avmplus_builtins.st"
verifyPass(sum >= 250 && sum <= 300, "sum >= 250 && sum <= 300", __FILE__, __LINE__);

}
void create_avmplus_builtins(AvmCore* core) { new ST_avmplus_builtins(core); }
}
}
#endif

// Generated from ST_avmplus_peephole.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if defined AVMPLUS_PEEPHOLE_OPTIMIZER
namespace avmplus {
namespace ST_avmplus_peephole {
class ST_avmplus_peephole : public Selftest {
public:
ST_avmplus_peephole(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();

private:
#ifdef AVMPLUS_DIRECT_THREADED
    void** opcode_labels; // the name is not arbitrary
#endif

};
ST_avmplus_peephole::ST_avmplus_peephole(AvmCore* core)
    : Selftest(core, "avmplus", "peephole", ST_avmplus_peephole::ST_names,ST_avmplus_peephole::ST_explicits)
{}
const char* ST_avmplus_peephole::ST_names[] = {"get2locals", NULL };
const bool ST_avmplus_peephole::ST_explicits[] = {false, false };
void ST_avmplus_peephole::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_avmplus_peephole::prologue() {

#ifdef AVMPLUS_DIRECT_THREADED
    opcode_labels = interpGetOpcodeLabels();
#endif

}
void ST_avmplus_peephole::epilogue() {

#ifdef AVMPLUS_DIRECT_THREADED
    opcode_labels = NULL; // interpGetOpcodeLables() returns a pointer to static data
#endif

}
void ST_avmplus_peephole::test0() {

    WordcodeEmitter* t = new WordcodeEmitter(core, NULL);

     t->emitOp1(WOP_getlocal, 5);
     t->emitOp1(WOP_getlocal, 4);
     t->emitOp1(WOP_getlocal, 65536);
     t->emitOp1(WOP_getlocal, 7);
     t->emitOp1(WOP_getlocal, 6);
     uintptr_t* code;
uint32_t len = (uint32_t)t->epilogue(&code);

// line 43 "ST_avmplus_peephole.st"
verifyPass(len == 6, "len == 6", __FILE__, __LINE__);
// line 44 "ST_avmplus_peephole.st"
verifyPass(code[0] == NEW_OPCODE(WOP_get2locals), "code[0] == NEW_OPCODE(WOP_get2locals)", __FILE__, __LINE__);
// line 45 "ST_avmplus_peephole.st"
verifyPass(code[1] == ((4 << 16) | 5), "code[1] == ((4 << 16) | 5)", __FILE__, __LINE__);
// line 46 "ST_avmplus_peephole.st"
verifyPass(code[2] == NEW_OPCODE(WOP_getlocal), "code[2] == NEW_OPCODE(WOP_getlocal)", __FILE__, __LINE__);
// line 47 "ST_avmplus_peephole.st"
verifyPass(code[3] == 65536, "code[3] == 65536", __FILE__, __LINE__);
// line 48 "ST_avmplus_peephole.st"
verifyPass(code[4] == NEW_OPCODE(WOP_get2locals), "code[4] == NEW_OPCODE(WOP_get2locals)", __FILE__, __LINE__);
// line 49 "ST_avmplus_peephole.st"
verifyPass(code[5] == ((6 << 16) | 7), "code[5] == ((6 << 16) | 7)", __FILE__, __LINE__);

    delete t;


}
void create_avmplus_peephole(AvmCore* core) { new ST_avmplus_peephole(core); }
}
}
#endif
#endif

// Generated from ST_avmplus_vector_accessors.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 609145 - VectorObject needs fast inline getter/setters
// Make sure the APIs, which are used by the Flash Player and AIR only, do not disappear.
//
// NOTE, the following comment is stale and we can fix the code, see the code for
// VectorAccessor further down for how to access a toplevel.
//
// We can't test them because we don't have access to a Toplevel*, but we can reference
// them, and a link error will ensue if they disappear.
//
// Code coverage will get worse with this test, not better.  C'est la guerre.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_avmplus_vector_accessors {

int32_t reference_getUintPropertyFast(IntVectorObject* obj, uint32_t x)
{
    return obj->getUintPropertyFast(x);
}

void reference_setUintPropertyFast(IntVectorObject* obj, uint32_t x, int32_t v)
{
    obj->setUintPropertyFast(x, v);
}

class ST_avmplus_vector_accessors : public Selftest {
public:
ST_avmplus_vector_accessors(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
};
ST_avmplus_vector_accessors::ST_avmplus_vector_accessors(AvmCore* core)
    : Selftest(core, "avmplus", "vector_accessors", ST_avmplus_vector_accessors::ST_names,ST_avmplus_vector_accessors::ST_explicits)
{}
const char* ST_avmplus_vector_accessors::ST_names[] = {"getOrSetUintPropertyFast","DataListAccessor_on_int","DataListAccessor_on_float4","VectorAccessor_on_int","VectorAccessor_on_float4", NULL };
const bool ST_avmplus_vector_accessors::ST_explicits[] = {false,false,false,false,false, false };
void ST_avmplus_vector_accessors::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
}
}
void ST_avmplus_vector_accessors::test0() {

// line 36 "ST_avmplus_vector_accessors.st"
verifyPass(true, "true", __FILE__, __LINE__);

}
void ST_avmplus_vector_accessors::test1() {

DataList<int> dl(core->GetGC(), 3);
dl.add(1);
dl.add(1);
dl.add(2);
dl.add(3);
dl.add(5);
dl.add(8);
dl.add(13);
DataListAccessor<int> dla(&dl);
int* xs = dla.addr();

// line 51 "ST_avmplus_vector_accessors.st"
verifyPass(xs[0] == 1, "xs[0] == 1", __FILE__, __LINE__);
// line 52 "ST_avmplus_vector_accessors.st"
verifyPass(xs[1] == 1, "xs[1] == 1", __FILE__, __LINE__);
// line 53 "ST_avmplus_vector_accessors.st"
verifyPass(xs[2] == 2, "xs[2] == 2", __FILE__, __LINE__);
// line 54 "ST_avmplus_vector_accessors.st"
verifyPass(xs[3] == 3, "xs[3] == 3", __FILE__, __LINE__);
// line 55 "ST_avmplus_vector_accessors.st"
verifyPass(xs[4] == 5, "xs[4] == 5", __FILE__, __LINE__);
// line 56 "ST_avmplus_vector_accessors.st"
verifyPass(xs[5] == 8, "xs[5] == 8", __FILE__, __LINE__);
// line 57 "ST_avmplus_vector_accessors.st"
verifyPass(xs[6] == 13, "xs[6] == 13", __FILE__, __LINE__);

}
void ST_avmplus_vector_accessors::test2() {

#ifdef VMCFG_FLOAT

DataList<float4_t, 16> dl4(core->GetGC(), 3);
float4_t x0 = { 1,1,2,3 };
float4_t x1 = { 5,8,13,21 };
float4_t x2 = { 34,55,89,144 };
dl4.add(x0);
dl4.add(x1);
dl4.add(x2);
DataListAccessor<float4_t,16> dla4(&dl4);
float4_t* x4s = dla4.addr();

// line 73 "ST_avmplus_vector_accessors.st"
verifyPass(f4_eq_i(x4s[0], x0) == 1, "f4_eq_i(x4s[0], x0) == 1", __FILE__, __LINE__);
// line 74 "ST_avmplus_vector_accessors.st"
verifyPass(f4_eq_i(x4s[1], x1) == 1, "f4_eq_i(x4s[1], x1) == 1", __FILE__, __LINE__);
// line 75 "ST_avmplus_vector_accessors.st"
verifyPass(f4_eq_i(x4s[2], x2) == 1, "f4_eq_i(x4s[2], x2) == 1", __FILE__, __LINE__);

#else

// line 79 "ST_avmplus_vector_accessors.st"
verifyPass(true, "true", __FILE__, __LINE__);

#endif

}
void ST_avmplus_vector_accessors::test3() {

#ifdef AVMSHELL_BUILD

avmshell::ShellCore* c = (avmshell::ShellCore*)core;
avmshell::ShellToplevel* top = c->shell_toplevel;
IntVectorObject* vec = top->intVectorClass()->newVector();

vec->_setNativeUintProperty(0, 1);
vec->_setNativeUintProperty(1, 1);
vec->_setNativeUintProperty(2, 2);
vec->_setNativeUintProperty(3, 3);
vec->_setNativeUintProperty(4, 5);
vec->_setNativeUintProperty(5, 8);
vec->_setNativeUintProperty(6, 13);

IntVectorAccessor va(vec);
int* xs = va.addr();

// line 102 "ST_avmplus_vector_accessors.st"
verifyPass(xs[0] == 1, "xs[0] == 1", __FILE__, __LINE__);
// line 103 "ST_avmplus_vector_accessors.st"
verifyPass(xs[1] == 1, "xs[1] == 1", __FILE__, __LINE__);
// line 104 "ST_avmplus_vector_accessors.st"
verifyPass(xs[2] == 2, "xs[2] == 2", __FILE__, __LINE__);
// line 105 "ST_avmplus_vector_accessors.st"
verifyPass(xs[3] == 3, "xs[3] == 3", __FILE__, __LINE__);
// line 106 "ST_avmplus_vector_accessors.st"
verifyPass(xs[4] == 5, "xs[4] == 5", __FILE__, __LINE__);
// line 107 "ST_avmplus_vector_accessors.st"
verifyPass(xs[5] == 8, "xs[5] == 8", __FILE__, __LINE__);
// line 108 "ST_avmplus_vector_accessors.st"
verifyPass(xs[6] == 13, "xs[6] == 13", __FILE__, __LINE__);

#else

// line 112 "ST_avmplus_vector_accessors.st"
verifyPass(true, "true", __FILE__, __LINE__);

#endif // AVMSHELL_BUILD

}
void ST_avmplus_vector_accessors::test4() {

#if defined VMCFG_FLOAT && defined AVMSHELL_BUILD

avmshell::ShellCore* c = (avmshell::ShellCore*)core;
avmshell::ShellToplevel* top = c->shell_toplevel;
Float4VectorObject* vec = top->float4VectorClass()->newVector();

float4_t x0 = { 1,1,2,3 };
float4_t x1 = { 5,8,13,21 };
float4_t x2 = { 34,55,89,144 };

vec->_setNativeUintProperty(0, x0);
vec->_setNativeUintProperty(1, x1);
vec->_setNativeUintProperty(2, x2);

Float4VectorAccessor va(vec);
float4_t* x4s = va.addr();

// line 135 "ST_avmplus_vector_accessors.st"
verifyPass(f4_eq_i(x4s[0], x0) == 1, "f4_eq_i(x4s[0], x0) == 1", __FILE__, __LINE__);
// line 136 "ST_avmplus_vector_accessors.st"
verifyPass(f4_eq_i(x4s[1], x1) == 1, "f4_eq_i(x4s[1], x1) == 1", __FILE__, __LINE__);
// line 137 "ST_avmplus_vector_accessors.st"
verifyPass(f4_eq_i(x4s[2], x2) == 1, "f4_eq_i(x4s[2], x2) == 1", __FILE__, __LINE__);

#else

// line 141 "ST_avmplus_vector_accessors.st"
verifyPass(true, "true", __FILE__, __LINE__);

#endif // AVMSHELL_BUILD

}
void create_avmplus_vector_accessors(AvmCore* core) { new ST_avmplus_vector_accessors(core); }
}
}
#endif

// Generated from ST_mmgc_543560.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 543560 - here we risk deleting an object that is still on the mark stack because
// of how we perform large-object splitting.  The setup is that user code that deletes the object
// gets to run after the first part of the large object has been popped off the mark stack
// but before the rest has been handled.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if defined AVMPLUS_WIN32
#if !defined VMCFG_ARM
namespace avmplus {
namespace ST_mmgc_bugzilla_543560 {
class ST_mmgc_bugzilla_543560 : public Selftest {
public:
ST_mmgc_bugzilla_543560(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
private:
    MMgc::GC *gc;

};
ST_mmgc_bugzilla_543560::ST_mmgc_bugzilla_543560(AvmCore* core)
    : Selftest(core, "mmgc", "bugzilla_543560", ST_mmgc_bugzilla_543560::ST_names,ST_mmgc_bugzilla_543560::ST_explicits)
{}
const char* ST_mmgc_bugzilla_543560::ST_names[] = {"bugzilla_543560", NULL };
const bool ST_mmgc_bugzilla_543560::ST_explicits[] = {false, false };
void ST_mmgc_bugzilla_543560::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_mmgc_bugzilla_543560::prologue() {
    MMgc::GCConfig config;
    gc = new MMgc::GC(MMgc::GCHeap::GetGCHeap(), config);

}
void ST_mmgc_bugzilla_543560::epilogue() {
    delete gc;

}
using namespace MMgc;

// allocate a bunch big things
// allocate a bunch of small things  ( to pump incremental mark.... )
// explicitly free one of the big things
// ... crash

struct BigThing;

static inline unsigned getSerial()
{
    static unsigned g_counter = 0;
    unsigned result = g_counter;
    ++g_counter;
    return result;
}

struct BigThing : public MMgc::GCFinalizedObject
{
    BigThing() : m_next(0), m_prev(0), m_serial(getSerial())
    {
        VMPI_memset(&m_data, 0, sizeof(m_data));
    }

    virtual ~BigThing()
    {
        //printf("~BigThing: %u 0x%08X 0x%08X\n", m_serial, this, this + 1);
    }
    GCMember<BigThing> m_next;
    GCMember<BigThing> m_prev;
    unsigned m_serial;
    char m_data[512 * 1024];
};

BigThing* makeBigThings(MMgc::GC* gc, size_t howMany)
{
    BigThing* first = 0;
    BigThing* curr = 0;
    for (unsigned i = 0; i < howMany; ++i) {
        BigThing* newThing = new (gc) BigThing();
        if (!first) {
            first = newThing;
        }
        else {
            curr->m_next = newThing;
            newThing->m_prev = curr;
        }
        curr = newThing;
    }
    return first;
}

struct SmallThing : public MMgc::GCFinalizedObject
{
    char m_data[200];
    virtual ~SmallThing()
    {
    }
};

struct MyRoot : public MMgc::GCRoot
{
    MyRoot(MMgc::GC* gc) : MMgc::GCRoot(gc) {}
    BigThing* m_bigThings;
};

void ST_mmgc_bugzilla_543560::test0() {
    MMGC_GCENTER(gc);

    MyRoot* theRoot = 0;
    {
        BigThing* volatile bigThings = makeBigThings(gc, 400);
        theRoot = new MyRoot(gc);
        theRoot->m_bigThings = bigThings;
    }
    BigThing* volatile middle = theRoot->m_bigThings;
    for (int j = 0 ; j < 150; ++j)
        middle = middle->m_next;

    middle->m_prev->m_next = 0;
    for (int j = 0; j < 50; ++j)
        middle = middle->m_next;

    middle->m_prev = 0;
    gc->Collect();
    gc->Collect();

    for (int j = 0; j < 100000; ++j) {
        //printf("j: %d\n", j);
        for (int i = 0; i < 500; ++i) {
            new (gc) SmallThing();
            if ((theRoot->m_bigThings) && (MMgc::GC::GetMark(theRoot->m_bigThings))) {
                while (theRoot->m_bigThings != 0) {
                    BigThing* curr = theRoot->m_bigThings;
                    theRoot->m_bigThings = theRoot->m_bigThings->m_next;
                    delete curr;
                }
                MMgc::GCHeap::GetGCHeap()->Decommit();
            }
        }

    }
    delete theRoot;

    // Will crash if it fails so the %%verify is just token
// line 135 "ST_mmgc_543560.st"
verifyPass(true, "true", __FILE__, __LINE__);

}
void create_mmgc_bugzilla_543560(AvmCore* core) { new ST_mmgc_bugzilla_543560(core); }
}
}
#endif
#endif
#endif

// Generated from ST_mmgc_575631.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 565631 - We occasionally interleave invoking finalizers
// and clearing mark bits in GCAlloc::Finalize; so a finalizer can
// observe a live object that does not have its mark bit set.
//
// This complicates things because we want to ensure that unmarked
// weakly-referenced objects are resurrected by the GC if the weak
// reference is dereferenced during presweep, but we do not want to
// schedule collection work (or set bits that are supposed to be
// unmarked) during finalization.
//
// (Long term we might want to get rid of the interleaving of
// finalization and mark-bit clearing.  Short term, lets just
// try to detect this on our own.)

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_bugzilla_575631 {
using namespace MMgc;

// Upon destruction, start reading weak refs of "friends" near and far
class Snoopy : public GCFinalizedObject
{
public:
    Snoopy(int key, GCWeakRef** refs, int len)
        : key(key), friends(refs), len(len)
    {
        ++alive_count;
    }
    ~Snoopy();
    static int alive_count;
private:
    int key;
    GCWeakRef** friends;
    int len;
};

// To take D samples from an array of N elems, walk thru by floor(N/D)
// steps (but avoid the pathological case when the floor is zero).
int compute_stride(int numerator, int denominator)
{
    int delta = numerator / denominator;
    return (delta > 0) ? delta : 1;
}

class ST_mmgc_bugzilla_575631 : public Selftest {
public:
ST_mmgc_bugzilla_575631(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
// collecting twice is only "sure" way to gc in presence of incrementality
void collect2() { core->gc->Collect(); core->gc->Collect(); }

};
ST_mmgc_bugzilla_575631::ST_mmgc_bugzilla_575631(AvmCore* core)
    : Selftest(core, "mmgc", "bugzilla_575631", ST_mmgc_bugzilla_575631::ST_names,ST_mmgc_bugzilla_575631::ST_explicits)
{}
const char* ST_mmgc_bugzilla_575631::ST_names[] = {"drizzle", NULL };
const bool ST_mmgc_bugzilla_575631::ST_explicits[] = {false, false };
void ST_mmgc_bugzilla_575631::run(int n) {
switch(n) {
case 0: test0(); return;
}
}

/*static*/ int Snoopy::alive_count = 0;

const int arr_len = 1000;
const int lookups_per_destruct = 10;
const int destructs = 10;
Snoopy::~Snoopy()
{
    int delta = compute_stride(arr_len, lookups_per_destruct);

    for ( int i = 1 ; i < arr_len ; i += delta ) {
        int idx = (key + i) % len;
        // printf("referencing ref[%d] from Snoopy(%d)\n", idx, key);
        friends[idx]->get();
    }
    --alive_count;
}

void ST_mmgc_bugzilla_575631::test0() {
{
    GC* gc = core->gc;

    Snoopy* objs[arr_len];
    GCWeakRef* refs[arr_len];

    // initial setup:
    for (int i=0 ; i < arr_len; ++i ) {
        objs[i] = new (gc) Snoopy(i, refs, arr_len);
        refs[i] = objs[i]->GetWeakRef();
    }

    collect2();

    int delta = compute_stride(arr_len, destructs);

    for (int i=0; i < arr_len; i += delta) {
        objs[i] = NULL;
        collect2();
    }

    // not assert failing within get() is passing the test.
// line 99 "ST_mmgc_575631.st"
verifyPass(1, "1", __FILE__, __LINE__);
          ; // (make my auto-indenter happy)

    // cleanup code; letting ~Snoopy occur outside test extent is big no-no.
    {
        for (int i=0; i < arr_len; ++i ) {
            if (! refs[i]->isNull())
                delete objs[i];
        }

        // if something went wrong above and some Snoopy's are still alive,
        // we'll get burned during their destructors.  Make sure that
        // does not happen.
// line 112 "ST_mmgc_575631.st"
verifyPass((Snoopy::alive_count == 0), "(Snoopy::alive_count == 0)", __FILE__, __LINE__);
              ;
    }
}

}
void create_mmgc_bugzilla_575631(AvmCore* core) { new ST_mmgc_bugzilla_575631(core); }
}
}
#endif

// Generated from ST_mmgc_580603.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 580603 - adversarial mmgc: dispersive w.r.t. address space
// Bugzilla 445780 - Page map needs to be sparse
// 
// Tommy: "problems in 64-bit linux b/c VMPI_allocateAlignedMemory provides
// memory from low 32 bit-addresses, and mmap is giving us addresses from
// 0x7fxxxxxxxxxxxxxx so we need a 4 GB page map."
//
// This self-test attempts to replicate the problem described above
// (by coordinating with an adversarial gcheap) thus illustrating the
// need for a sparse page map.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if defined AVMPLUS_64BIT && defined DEBUG
namespace avmplus {
namespace ST_mmgc_bugzilla_580603 {
using namespace MMgc;

class ST_mmgc_bugzilla_580603 : public Selftest {
public:
ST_mmgc_bugzilla_580603(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();

GC *gc;
GCHeap *heap;

size_t saved_dispersiveAdversarial;
size_t saved_heapLimit;

char *min_addr;
char *max_start;
char *max_addr;
size_t min_size;
size_t max_size;

static const int m_num_sizes = 17;
static const int m_num_iters =  2;
static const int m_init_size = 16;
static const int m_dfactor   =  2;

void print_minmax()
{
    intptr_t delta = max_addr - min_addr;
    intptr_t v = delta;
    unsigned r = 0; // r will be floor(log_2(v))

    while (v >>= 1)
        r++;

    printf("min_size: 0x%15lx max_size: 0x%15lx\n",
           (unsigned long)min_size, (unsigned long)max_size);
    printf("min_addr: 0x%15lx max_addr: 0x%15lx delta:% 15ld (>= 2^%u)\n",
           (unsigned long)min_addr, (unsigned long)max_addr, delta, r);
    fflush(NULL);
}

enum alloc_method_t { via_gc, via_heap };

const char* method_string(alloc_method_t m)
{
    switch (m) {
    case via_gc:     return "via_gc";
    case via_heap:   return "via_heap";
    default: return 0;
    }
}

char *my_alloc(size_t size, alloc_method_t m)
{
    char *ret;

    // Took heap-zeroing and heap-profiling out of flags;
    // avoid wasting time mapping in memory to initialize to 0.
    int heapFlags = (MMgc::GCHeap::kExpand);
    size_t sizeInPages = (size+(GCHeap::kBlockSize-1))/GCHeap::kBlockSize;

    switch (m) {
    case via_gc:     ret = (char*)gc->Alloc(size); break;
    case via_heap:
        ret = (char*)heap->Alloc(sizeInPages, heapFlags);
        break;
    default: ret = 0; break;
    }

    if (size < min_size)
        min_size = size;
    if (size > max_size)
        max_size = size;
    if (ret < min_addr)
        min_addr = ret;
    if (ret > max_start)
        max_start = ret;
    if (ret+size > max_addr)
        max_addr = ret+size;

    // printf("my_alloc(%10ld, %10s) => %p\n", size, method_string(m), ret);
    // fflush(NULL);
    return ret;
}

void my_free(char *p, alloc_method_t m)
{
    switch (m) {
    case via_gc:     gc->Free(p); return;
    case via_heap:   heap->FreeNoProfile(p); return;
    default: AvmAssert(p == 0); return;
    }
}

// fills recv[] with the addresses of a series of N allocated and
// freed blocks, where N = (m_num_iters * m_num_sizes).
//
// For each iteration:
//
// 1. allocate m_num_sizes blocks of distinct (and exponentially
//    growing) size.
// 2. after finishing the allocations from (1.), free the blocks
//    allocated in the *previous* iteration.
//
// The intention is to allocate blocks covering a wide range of
// sizes in order to tickle the memory subsystem's ability to
// track blocks of different sizes.  Keeping each iteration's
// blocks alive across the next iteration is meant to ensure
// that the set of allocated addresses have many wide gaps,
// stressing the memory subsystem's ability to represent
// the meta-data for disparately allocated ranges.
//
// The loop attempts to keep the block sizes distinct both within any
// particular iteration (the exponential growth) and also across the
// distinct iterations.  This was an artifact of trying to force the
// memory subsystem to be unable to return back blocks that had been
// previously freed.  It may or may not still be necessary with the
// addition of the dispersiveAdversarial gcheap config mode; it does
// not seem to hurt the effectiveness of this test, since one can
// observe OOM failures when using PageMap::Uniform using this test;
// see notes in prologue code below.

void do_allocs(char **recv, alloc_method_t m)
{
    size_t init   = m_init_size;
    int num_iters = m_num_iters;
    int num_sizes = m_num_sizes;
    int dfactor   = m_dfactor;
    for (int j=num_iters-1; j >= 0; j--) {
        for (int i=0, factor=1; i < num_sizes; i++, factor*=dfactor) {
            size_t size = factor*init+num_iters-j;
            // size_t size = factor*init;
            char *result = my_alloc(size, m);
            recv[j*num_sizes+i] = result;
        }
        if (j < num_iters - 1) {
            for (int i=0; i < num_sizes; i++) {
                my_free(recv[(j+1)*num_sizes+i], m);
            }
        }
    }
    for (int i=0; i < num_sizes; i++) {
        my_free(recv[0*num_sizes+i], m);
    }
}


};
ST_mmgc_bugzilla_580603::ST_mmgc_bugzilla_580603(AvmCore* core)
    : Selftest(core, "mmgc", "bugzilla_580603", ST_mmgc_bugzilla_580603::ST_names,ST_mmgc_bugzilla_580603::ST_explicits)
{}
const char* ST_mmgc_bugzilla_580603::ST_names[] = {"alloc_loop_mmgc_viaheap_far","alloc_loop_mmgc_viagc_far", NULL };
const bool ST_mmgc_bugzilla_580603::ST_explicits[] = {false,false, false };
void ST_mmgc_bugzilla_580603::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
}
}
void ST_mmgc_bugzilla_580603::prologue() {
{
    min_addr = (char*)(void*)-1;
    min_size = (size_t)(void*)-1;
    max_addr = 0;
    max_size = 0;

    // based on ST_mmgc_basics.st
    heap = MMgc::GCHeap::GetGCHeap();

    // Constants determining test parameters; see comments below.
    const int k1 = 40;
    const int k2 = 15;

    // filler that GCHeap attempts to insert between allocations,
    // in bytes (not that the precise number matters).
    saved_dispersiveAdversarial = heap->Config().dispersiveAdversarial;
    heap->Config().dispersiveAdversarial = size_t(1) << k1;
    // limit is measured in pages; 1 page = kBlockSize bytes.
    // its default value is absurdly large; cut it down to something
    // where we'll see a failure without first hosing the host machine.
    saved_heapLimit = heap->Config().heapLimit;
    heap->Config().heapLimit = ((1 << k2)-1);

    // Some pairs of (k1,k2) for filler = 2**k1 and limit = 2**k2 - 1,
    // where the (decreasing) value of k2 has just passed threshold to
    // expose OOM from PageMap::Uniform (i.e. limit = 2**(k2+1) - 1
    // won't OOM); test bed is 64-bit DEBUG avmshell on Mac OS X 10.6.4.
    //
    // k1, k2
    // ------
    // 43, 18
    // 42, 17
    // 41, 16
    // 40, 15
    // 39, 14
    // 38, 13
    // 37, 12
    // 36, 12
    // 35, 11
    // 34, 11
    //
    // For k1 < 34, test won't OOM for k2 >= 11.
    // For k2 < 11, test will OOM w/o dispersiveAdversarial at all.

    gc = core->gc;
}

}
void ST_mmgc_bugzilla_580603::epilogue() {
{
    // restore original values to limit disruption to remaining selftests
    heap->Config().heapLimit = this->saved_heapLimit;
    heap->Config().dispersiveAdversarial = saved_dispersiveAdversarial;
}

}

void ST_mmgc_bugzilla_580603::test0() {
{
    char *h[3];
    h[0] = my_alloc( 256*GCHeap::kBlockSize, via_heap);
    h[1] = my_alloc( 256*GCHeap::kBlockSize, via_heap);
    my_free(h[0], via_heap);
    my_free(h[1], via_heap);
    // print_minmax();

    char *g[m_num_iters*m_num_sizes]; (void)g;
    do_allocs(g, via_heap);

    // print_minmax();

// line 242 "ST_mmgc_580603.st"
verifyPass(1, "1", __FILE__, __LINE__);
}

}
void ST_mmgc_bugzilla_580603::test1() {
{
    char *h[3];
    h[0] = my_alloc( 256*GCHeap::kBlockSize, via_heap);
    h[1] = my_alloc( 256*GCHeap::kBlockSize, via_heap);
    my_free(h[0], via_heap);
    my_free(h[1], via_heap);
    // print_minmax();

    char *g[m_num_iters*m_num_sizes]; (void)g;
    do_allocs(g, via_gc);

    // print_minmax();

// line 259 "ST_mmgc_580603.st"
verifyPass(1, "1", __FILE__, __LINE__);
}

}
void create_mmgc_bugzilla_580603(AvmCore* core) { new ST_mmgc_bugzilla_580603(core); }
}
}
#endif
#endif

// Generated from ST_mmgc_603411.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bug 603411 - SECURITY: AvmCore dtor needs to clear CallStackNode chain

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if defined DEBUGGER
namespace avmplus {
namespace ST_mmgc_bugzilla_603411 {

class MyDebugger : public Debugger
{
public:
    MyDebugger(AvmCore *core, avmplus::Debugger::TraceLevel tracelevel) : Debugger(core, tracelevel) {}
    ~MyDebugger() {}

    virtual void enterDebugger() {}
    virtual bool filterException(avmplus::Exception*, bool) { return false; }
    virtual bool hitWatchpoint() {return false; }
};


class MyToplevel: public avmplus::Toplevel 
{
    public:
    MyToplevel(avmplus::AbcEnv* env)
        : Toplevel(env) {}
    virtual GCRef<avmplus::ClassClosure> workerClass() const
    {
        return NULL;
    }
    
    virtual GCRef<avmplus::ClassClosure> workerDomainClass() const
    {
        return NULL;
    }

    virtual GCRef<avmplus::ScriptObject> constructWorkerObject() const
    {
        return NULL;
    }
    
};

class MyAvmCore : public avmplus::AvmCore
{
public:
    MyAvmCore(MMgc::GC* gc) : AvmCore(gc, kApiVersionSeries_FP) { initBuiltinPool(1); }
    ~MyAvmCore() {}

    virtual void interrupt(Toplevel*, InterruptReason) { }
    virtual void stackOverflow(Toplevel*) { }
    virtual avmplus::String* readFileForEval(avmplus::String*, avmplus::String*) { return NULL; }
    virtual avmplus::ApiVersion getDefaultAPI() { return kApiVersion_VM_INTERNAL; }
    virtual avmplus::Toplevel* createTopLevel(avmplus::AbcEnv*)
    {
        return NULL;
    }
    Debugger* createDebugger(int tracelevel) { return new (this->gc) MyDebugger(this, (avmplus::Debugger::_TraceLevel)tracelevel); }

    virtual avmplus::Toplevel* createToplevel(avmplus::AbcEnv* env) { 
        return new (gc) MyToplevel(env);
    }

};


class MyTestClass
{
public:
    MyTestClass(MyAvmCore* core) : m_core(core)
    {
        (void)core;
    }

    void testAvmCoreDelete()
    {
        // create CallStackNode
        CallStackNode csn(m_core, "Date");

        // delete core
        delete m_core;
    }
private:
    MyAvmCore* m_core;
};

class ST_mmgc_bugzilla_603411 : public Selftest {
public:
ST_mmgc_bugzilla_603411(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
private:
    MyTestClass* testClass;
    MyAvmCore*   testCore;
};
ST_mmgc_bugzilla_603411::ST_mmgc_bugzilla_603411(AvmCore* core)
    : Selftest(core, "mmgc", "bugzilla_603411", ST_mmgc_bugzilla_603411::ST_names,ST_mmgc_bugzilla_603411::ST_explicits)
{}
const char* ST_mmgc_bugzilla_603411::ST_names[] = {"test1", NULL };
const bool ST_mmgc_bugzilla_603411::ST_explicits[] = {false, false };
void ST_mmgc_bugzilla_603411::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_mmgc_bugzilla_603411::prologue() {

}
void ST_mmgc_bugzilla_603411::epilogue() {
    testClass = NULL;
    testCore = NULL;

}
void ST_mmgc_bugzilla_603411::test0() {
    // create our own core
    testCore = new MyAvmCore(core->gc);
    testClass = new MyTestClass(testCore);
    testClass->testAvmCoreDelete();

// line 108 "ST_mmgc_603411.st"
verifyPass(true, "true", __FILE__, __LINE__);

}
void create_mmgc_bugzilla_603411(AvmCore* core) { new ST_mmgc_bugzilla_603411(core); }
}
}
#endif
#endif

// Generated from ST_mmgc_637993.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 637993: rehashing a GCHashtable in the midst of iteration
// is unsound; here we check that we are guarding against it.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_bugzilla_637993 {
class ST_mmgc_bugzilla_637993 : public Selftest {
public:
ST_mmgc_bugzilla_637993(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();

const static size_t elem_count = 1000;
int32_t *elems;
MMgc::GCHashtable m_table;

void add_first_half() {
    for (size_t i=0; i < elem_count/2; i++)
        m_table.put(&elems[i], &elems[i+1]);
}

void add_second_half() {
    for (size_t i=elem_count/2; i < elem_count; i++)
        m_table.put(&elems[i], &elems[i+1]);
}

};
ST_mmgc_bugzilla_637993::ST_mmgc_bugzilla_637993(AvmCore* core)
    : Selftest(core, "mmgc", "bugzilla_637993", ST_mmgc_bugzilla_637993::ST_names,ST_mmgc_bugzilla_637993::ST_explicits)
{}
const char* ST_mmgc_bugzilla_637993::ST_names[] = {"delete_during_iteration_okay_if_norehash","delete_during_iteration_asserts_if_rehash","rehash_after_iteration_succeeds","rehash_during_iteration_assert_fails_1","rehash_during_iteration_assert_fails_2", NULL };
const bool ST_mmgc_bugzilla_637993::ST_explicits[] = {false,true,false,true,true, false };
void ST_mmgc_bugzilla_637993::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
}
}
void ST_mmgc_bugzilla_637993::test0() {
    elems = new int32_t[elem_count];
    add_first_half();
    {
        MMgc::GCHashtable::Iterator it(&m_table);
        while (it.nextKey()) {
            m_table.remove(it.value(), /*allowrehash=*/false);
        }
    }
    m_table.clear();
    delete elems;
// line 41 "ST_mmgc_637993.st"
verifyPass(true, "true", __FILE__, __LINE__);
         ;

}
void ST_mmgc_bugzilla_637993::test1() {
    elems = new int32_t[elem_count];
    add_first_half();
    {
        MMgc::GCHashtable::Iterator it(&m_table);
        while (it.nextKey()) {
            m_table.remove(it.value());
        }
    }
    m_table.clear();
    delete elems;
// line 55 "ST_mmgc_637993.st"
verifyPass(false, "false", __FILE__, __LINE__);
         ;

// This test is a trivial success; it is meant to be compared against
// the cases that *fail* below, in order to make it clear what is
// wrong with the intentionally asserting cases.
}
void ST_mmgc_bugzilla_637993::test2() {
    elems = new int32_t[elem_count];
    add_first_half();
    {
        MMgc::GCHashtable::Iterator it(&m_table);
        it.nextKey();
        it.nextKey();
    }
    add_second_half(); // rule satisfied; (Iterator is out of scope).
    m_table.clear();
    delete elems;
// line 72 "ST_mmgc_637993.st"
verifyPass(true, "true", __FILE__, __LINE__);
         ;

  // (This test should definitely assert.)
}
void ST_mmgc_bugzilla_637993::test3() {
    elems = new int32_t[elem_count];
    add_first_half();
    {
        MMgc::GCHashtable::Iterator it(&m_table);
        it.nextKey();
        add_second_half(); // this is where we break the rule
        it.nextKey();
    }

    m_table.clear();
    delete elems;
    // we should never get here, the assertion should happen up above.
// line 89 "ST_mmgc_637993.st"
verifyPass(false, "false", __FILE__, __LINE__);
          ;

// This test will assert even though the iteration is "done",
// because the rule is that we cannot modify the hashtable while
// any iterator is still "in scope"
}
void ST_mmgc_bugzilla_637993::test4() {
    elems = new int32_t[elem_count];
    add_first_half();
    {
        MMgc::GCHashtable::Iterator it(&m_table);
        it.nextKey();
        it.nextKey();
        add_second_half(); // this is where we break the rule
    }

    m_table.clear();
    delete elems;
    // we should never get here, the assertion should happen up above.
// line 108 "ST_mmgc_637993.st"
verifyPass(false, "false", __FILE__, __LINE__);
          ;

}
void create_mmgc_bugzilla_637993(AvmCore* core) { new ST_mmgc_bugzilla_637993(core); }
}
}
#endif

// Generated from ST_mmgc_basics.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_basics {
class ST_mmgc_basics : public Selftest {
public:
ST_mmgc_basics(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
void test8();
void test9();
void test10();
void test11();
void test12();
void test13();
void test14();
void test15();
void test16();
void test17();
private:
    MMgc::GC *gc;
    MMgc::FixedAlloc *fa;
    MMgc::FixedMalloc *fm;

};
ST_mmgc_basics::ST_mmgc_basics(AvmCore* core)
    : Selftest(core, "mmgc", "basics", ST_mmgc_basics::ST_names,ST_mmgc_basics::ST_explicits)
{}
const char* ST_mmgc_basics::ST_names[] = {"create_gc_instance","create_gc_object","get_bytesinuse","collect","getgcheap","fixedAlloc","fixedMalloc","gcheap","gcheapAlign","gcmethods","finalizerAlloc","finalizerDelete","nestedGCs","collectDormantGC","lockObject","regression_551169","blacklisting","get_bytesinusefast", NULL };
const bool ST_mmgc_basics::ST_explicits[] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false, false };
void ST_mmgc_basics::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
case 5: test5(); return;
case 6: test6(); return;
case 7: test7(); return;
case 8: test8(); return;
case 9: test9(); return;
case 10: test10(); return;
case 11: test11(); return;
case 12: test12(); return;
case 13: test13(); return;
case 14: test14(); return;
case 15: test15(); return;
case 16: test16(); return;
case 17: test17(); return;
}
}
void ST_mmgc_basics::prologue() {
    MMgc::GCConfig config;
    gc=new MMgc::GC(MMgc::GCHeap::GetGCHeap(), config);
    if (gc==NULL) {
        MMgc::GCHeap::Init();
        gc=new MMgc::GC(MMgc::GCHeap::GetGCHeap(), config);
    }

}
void ST_mmgc_basics::epilogue() {
delete gc;

}
using namespace MMgc;
class DeleteInFinalizer : public GCFinalizedObject {
 public:
  // note "small" is a reserved identifier in Visual C++ for Windows Mobile (#defined to be 'char')
  DeleteInFinalizer(GCFinalizedObject *big, GCFinalizedObject *small_) : big(big), small_(small_) {};
  ~DeleteInFinalizer() { delete big; delete small_; }
 private:
  GCFinalizedObject *big;
  GCFinalizedObject *small_;
};

// Any small object would do
class AllocInFinalizer2 : public GCObject {
public:
    void* dummy;
};

class AllocInFinalizer : public GCFinalizedObject {
public:
    AllocInFinalizer() {}
    ~AllocInFinalizer() { new (GC::GetGC(this)) AllocInFinalizer2(); }
};

class LockableObject : public GCFinalizedObject {
public:
    LockableObject(int* counter) : counter(counter) {}
    virtual ~LockableObject() {
        *counter = *counter + 1;
    }
    int * const counter;
};

class LockerAndUnlocker
{
public:   
    static const int numlocked = 100;
    static GCObjectLock* lock[numlocked];
    static GCObjectLock* lock2[numlocked];
    static int counter;
    
    static bool createAndLockObjects(GC* gc) {
        counter = 0;
        for ( int i=0 ; i < numlocked ; i++ )
            lock[i] = gc->LockObject(new (gc) LockableObject(&counter));
        return true;
    }

    static bool lockLevel2(GC* gc) {
        for ( int i=0 ; i < numlocked ; i++ )
            lock2[i] = gc->LockObject(gc->GetLockedObject(lock[i]));
        return true;
    }

    static bool testLocksHeld(GC* gc, int level) {
        if (counter != 0)
            return false;

        int held = 0;
        for ( int i=0 ; i < numlocked ; i++ )
            held += bool(gc->GetLockedObject(lock[i]) != NULL);
        if (level > 1)
            for ( int i=0 ; i < numlocked ; i++ )
                held += bool(gc->GetLockedObject(lock2[i]) != NULL);

        if (held != level*numlocked)
            return false;
            
        return true;
    }
    
    static bool testLocksNotHeld(GC*) {
        // At least some of the destructors should have run...
        if (counter < numlocked/2)
            return false;
        return true;
    }

    static bool unlockLevel2(GC* gc) {
        for ( int i=0 ; i < numlocked ; i++ )
            gc->UnlockObject(lock2[i]);
        return true;
    }

    static bool unlockLevel1(GC* gc) {
        for ( int i=0 ; i < numlocked ; i++ ) {
#ifdef MMGC_HEAP_GRAPH
            gc->addToBlacklist(gc->GetLockedObject(lock[i]));
#endif
            gc->UnlockObject(lock[i]);
        }
        return true;
    }
};

GCObjectLock* LockerAndUnlocker::lock[numlocked];
GCObjectLock* LockerAndUnlocker::lock2[numlocked];
int LockerAndUnlocker::counter = 0;

void ST_mmgc_basics::test0() {
// line 128 "ST_mmgc_basics.st"
verifyPass(gc != NULL, "gc != NULL", __FILE__, __LINE__);

}
void ST_mmgc_basics::test1() {
    MMGC_GCENTER(gc);
    MyGCObject *mygcobject;
    mygcobject = (MyGCObject *)new (gc) MyGCObject();
// line 134 "ST_mmgc_basics.st"
verifyPass(mygcobject!=NULL, "mygcobject!=NULL", __FILE__, __LINE__);
    mygcobject->i=10;
// line 136 "ST_mmgc_basics.st"
verifyPass(mygcobject->i==10, "mygcobject->i==10", __FILE__, __LINE__);

}
void ST_mmgc_basics::test2() {
    MMGC_GCENTER(gc);
    MyGCObject *mygcobject;
    int inuse=(int)gc->GetBytesInUse();
    mygcobject = (MyGCObject *)new (gc) MyGCObject();
//    AvmLog("bytes in use before %d after %d\n",inuse,(int)gc->GetBytesInUse());
// line 144 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse()==inuse + sizeof(MyGCObject) + DebugSize(), "gc->GetBytesInUse()==inuse + sizeof(MyGCObject) + DebugSize()", __FILE__, __LINE__);
    delete mygcobject;

}
void ST_mmgc_basics::test3() {
    MMGC_GCENTER(gc);
    MyGCObject *mygcobject;
    int inuse=(int)gc->GetBytesInUse();
    mygcobject = (MyGCObject *)new (gc) MyGCObject();
// line 152 "ST_mmgc_basics.st"
verifyPass((int)gc->GetBytesInUse()>inuse, "(int)gc->GetBytesInUse()>inuse", __FILE__, __LINE__);
    delete mygcobject;
//    AvmLog("collect: inuse=%d current=%d\n",inuse,(int)gc->GetBytesInUse());
    gc->Collect();
//    AvmLog("collect: inuse=%d current=%d\n",inuse,(int)gc->GetBytesInUse());
// line 157 "ST_mmgc_basics.st"
verifyPass((int)gc->GetBytesInUse()<=inuse, "(int)gc->GetBytesInUse()<=inuse", __FILE__, __LINE__);

}
void ST_mmgc_basics::test4() {
// line 160 "ST_mmgc_basics.st"
verifyPass(gc->GetGCHeap()!=NULL, "gc->GetGCHeap()!=NULL", __FILE__, __LINE__);

}
void ST_mmgc_basics::test5() {
    MMgc::FixedAlloc *fa;
    fa=new MMgc::FixedAlloc(2048,MMgc::GCHeap::GetGCHeap());
// line 165 "ST_mmgc_basics.st"
verifyPass((int)fa->GetMaxAlloc()==0, "(int)fa->GetMaxAlloc()==0", __FILE__, __LINE__);
// line 166 "ST_mmgc_basics.st"
verifyPass((int)fa->GetNumBlocks()==0, "(int)fa->GetNumBlocks()==0", __FILE__, __LINE__);
    void *data1=fa->Alloc(2048);
// line 168 "ST_mmgc_basics.st"
verifyPass(MMgc::FixedAlloc::GetFixedAlloc(data1)==fa, "MMgc::FixedAlloc::GetFixedAlloc(data1)==fa", __FILE__, __LINE__);
// line 169 "ST_mmgc_basics.st"
verifyPass(fa->GetBytesInUse()==DebugSize()+2048, "fa->GetBytesInUse()==DebugSize()+2048", __FILE__, __LINE__);
// line 170 "ST_mmgc_basics.st"
verifyPass(fa->GetItemSize()==2048, "fa->GetItemSize()==2048", __FILE__, __LINE__);
    void *data2=fa->Alloc(2048);
// line 172 "ST_mmgc_basics.st"
verifyPass(MMgc::FixedAlloc::GetFixedAlloc(data2)==fa, "MMgc::FixedAlloc::GetFixedAlloc(data2)==fa", __FILE__, __LINE__);
//    AvmLog("fa->GetItemSize=%d\n",(int)fa->GetItemSize());
// line 174 "ST_mmgc_basics.st"
verifyPass((int)fa->GetItemSize()==2048, "(int)fa->GetItemSize()==2048", __FILE__, __LINE__);
    fa->Free(data1);
// line 176 "ST_mmgc_basics.st"
verifyPass((int)fa->GetItemSize()==2048, "(int)fa->GetItemSize()==2048", __FILE__, __LINE__);
// line 177 "ST_mmgc_basics.st"
verifyPass((int)fa->GetMaxAlloc()==1, "(int)fa->GetMaxAlloc()==1", __FILE__, __LINE__);
// line 178 "ST_mmgc_basics.st"
verifyPass((int)fa->GetNumBlocks()==1, "(int)fa->GetNumBlocks()==1", __FILE__, __LINE__);
    fa->Free(data2);
    delete fa;

}
void ST_mmgc_basics::test6() {
    fm=MMgc::FixedMalloc::GetFixedMalloc();
    int start=(int)fm->GetBytesInUse();
    int starttotal=(int)fm->GetTotalSize();
//    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
// line 187 "ST_mmgc_basics.st"
verifyPass((int)fm->GetBytesInUse()==start, "(int)fm->GetBytesInUse()==start", __FILE__, __LINE__);
//    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
// line 189 "ST_mmgc_basics.st"
verifyPass((int)fm->GetTotalSize()==starttotal, "(int)fm->GetTotalSize()==starttotal", __FILE__, __LINE__);
    void *obj=fm->Alloc(8192);
//    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
//    %%verify fm->GetBytesInUse()==start + 8192 + MMgc::DebugSize()
//    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
//    %%verify (int)fm->GetTotalSize()==starttotal+2
    fm->Free(obj);
//    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
// line 197 "ST_mmgc_basics.st"
verifyPass((int)fm->GetBytesInUse()==start, "(int)fm->GetBytesInUse()==start", __FILE__, __LINE__);
//    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
// line 199 "ST_mmgc_basics.st"
verifyPass((int)fm->GetTotalSize()==starttotal, "(int)fm->GetTotalSize()==starttotal", __FILE__, __LINE__);
    obj=fm->Calloc(1024,10);
//    AvmLog("fm->GetBytesInUse()=%d\n",(int)fm->GetBytesInUse());
// FixedMalloc is currently (as of redux 3229) tracking large allocs using a list of
// small objects, in some debug modes.  So we can't have a precise test here.
// line 204 "ST_mmgc_basics.st"
verifyPass((int)fm->GetBytesInUse()>=start+1024*12 && (int)fm->GetBytesInUse()<=start+1024*12+64, "(int)fm->GetBytesInUse()>=start+1024*12 && (int)fm->GetBytesInUse()<=start+1024*12+64", __FILE__, __LINE__);
//    AvmLog("fm->GetTotalSize()=%d\n",(int)fm->GetTotalSize());
// line 206 "ST_mmgc_basics.st"
verifyPass((int)fm->GetTotalSize()==starttotal+3, "(int)fm->GetTotalSize()==starttotal+3", __FILE__, __LINE__);
    fm->Free(obj);
// line 208 "ST_mmgc_basics.st"
verifyPass((int)fm->GetBytesInUse()==start, "(int)fm->GetBytesInUse()==start", __FILE__, __LINE__);
// line 209 "ST_mmgc_basics.st"
verifyPass((int)fm->GetTotalSize()==starttotal, "(int)fm->GetTotalSize()==starttotal", __FILE__, __LINE__);

}
void ST_mmgc_basics::test7() {
    MMgc::GCHeap *gh=MMgc::GCHeap::GetGCHeap();
    int startfreeheap=(int)gh->GetFreeHeapSize();
//    %%verify (int)gh->GetTotalHeapSize()==128
//    AvmLog("gh->GetFreeHeapSize()=%d\n",(int)gh->GetFreeHeapSize());
// line 216 "ST_mmgc_basics.st"
verifyPass((int)gh->GetFreeHeapSize()==startfreeheap, "(int)gh->GetFreeHeapSize()==startfreeheap", __FILE__, __LINE__);
//gh->Config().heapLimit = 1024;
//    %%verify (int)gh->GetTotalHeapSize()==128
//    AvmLog("gh->GetFreeHeapSize()=%d\n",(int)gh->GetFreeHeapSize());
// line 220 "ST_mmgc_basics.st"
verifyPass((int)gh->GetFreeHeapSize()==startfreeheap, "(int)gh->GetFreeHeapSize()==startfreeheap", __FILE__, __LINE__);
    void *data = gh->Alloc(10,MMgc::GCHeap::kExpand | MMgc::GCHeap::kZero);
// line 222 "ST_mmgc_basics.st"
verifyPass((int)gh->GetTotalHeapSize()>startfreeheap, "(int)gh->GetTotalHeapSize()>startfreeheap", __FILE__, __LINE__);
//    AvmLog("gh->GetFreeHeapSize()=%d\n",(int)gh->GetFreeHeapSize());
    gh->FreeNoProfile(data);
       
}
void ST_mmgc_basics::test8() {
    MMgc::GCHeap *gh=MMgc::GCHeap::GetGCHeap();

    // Tricky: try to provoke some internal asserts
    void *d[1000];
    for ( unsigned i=0 ; i < ARRAY_SIZE(d) ; i++ ) {
        d[i] = gh->Alloc(1);
        void *data = gh->Alloc(10,MMgc::GCHeap::flags_Alloc, 4);
        gh->Free(data);
    }
    for ( unsigned i=0 ; i < ARRAY_SIZE(d) ; i++ )
        gh->Free(d[i]);

    // 
    for ( size_t k=2 ; k <= 256 ; k *= 2 ) {
        void *data = gh->Alloc(10,MMgc::GCHeap::flags_Alloc, k);
// line 242 "ST_mmgc_basics.st"
verifyPass(((uintptr_t)data & (k*MMgc::GCHeap::kBlockSize - 1)) == 0, "((uintptr_t)data & (k*MMgc::GCHeap::kBlockSize - 1)) == 0", __FILE__, __LINE__);
// line 243 "ST_mmgc_basics.st"
verifyPass(gh->Size(data) == 10, "gh->Size(data) == 10", __FILE__, __LINE__);
        gh->Free(data);
    }

}
void ST_mmgc_basics::test9() {
    MMGC_GCENTER(gc);
    MyGCObject *mygcobject;
    mygcobject = (MyGCObject *)new (gc) MyGCObject();
// line 251 "ST_mmgc_basics.st"
verifyPass((MyGCObject *)gc->FindBeginningGuarded(mygcobject)==mygcobject, "(MyGCObject *)gc->FindBeginningGuarded(mygcobject)==mygcobject", __FILE__, __LINE__);
// line 252 "ST_mmgc_basics.st"
verifyPass((MyGCObject *)gc->FindBeginningFast(mygcobject)==mygcobject, "(MyGCObject *)gc->FindBeginningFast(mygcobject)==mygcobject", __FILE__, __LINE__);

// Bugzilla 542529 - in debug mode we would assert here due to logic flaws in the allocatr
}
void ST_mmgc_basics::test10() {
    MMGC_GCENTER(gc);
    new (gc) AllocInFinalizer();
    gc->Collect(false);
// line 259 "ST_mmgc_basics.st"
verifyPass(true, "true", __FILE__, __LINE__);

}
void ST_mmgc_basics::test11() {
    MMGC_GCENTER(gc);
    new (gc) DeleteInFinalizer(new (gc, 100) GCFinalizedObject(), new (gc) GCFinalizedObject());
    //delete m; delete m; // this verifies we crash, it does
    gc->Collect(false);
// line 266 "ST_mmgc_basics.st"
verifyPass(true, "true", __FILE__, __LINE__);
    GCFinalizedObject *gcfo = new (gc) GCFinalizedObject();
    gcfo->~GCFinalizedObject();
    gcfo->~GCFinalizedObject(); // this used to be a deleteing dtor and would crash, not anymore



}
void ST_mmgc_basics::test12() {
    GCConfig config;
    GC *gcb = new GC(GCHeap::GetGCHeap(), config);
    MMGC_GCENTER(gc);
    void *a = gc->Alloc(8);
    {
        MMGC_GCENTER(gcb);
        a = gcb->Alloc(8);
        {
            MMGC_GCENTER(gc);
            a = gc->Alloc(8);
        }
        a = gcb->Alloc(8);
    }
    a = gc->Alloc(8);
    // just fishing for asserts/hangs/crashes
// line 289 "ST_mmgc_basics.st"
verifyPass(true, "true", __FILE__, __LINE__);
    delete gcb;

}
void ST_mmgc_basics::test13() {
    {
        GCConfig config;
        GC *gcb = new GC(GCHeap::GetGCHeap(), config);
        {
            MMGC_GCENTER(gcb);
            gcb->Alloc(8);
        }

        // this will cause a Collection in gcb
        GCHeap::SignalExternalFreeMemory();
        delete gcb;

        // just fishing for asserts/hangs/crashes
// line 306 "ST_mmgc_basics.st"
verifyPass(true, "true", __FILE__, __LINE__);
    }

}
void ST_mmgc_basics::test14() {
    {
        GCConfig config;
        GC *gc = new GC(GCHeap::GetGCHeap(), config);
        MMGC_GCENTER(gc);

// line 315 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::createAndLockObjects(gc), "LockerAndUnlocker::createAndLockObjects(gc)", __FILE__, __LINE__);
        gc->Collect();
        gc->Collect();
// line 318 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::testLocksHeld(gc, 1), "LockerAndUnlocker::testLocksHeld(gc, 1)", __FILE__, __LINE__);
        gc->Collect();
        gc->Collect();
// line 321 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::lockLevel2(gc), "LockerAndUnlocker::lockLevel2(gc)", __FILE__, __LINE__);
        gc->Collect();
        gc->Collect();
// line 324 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::testLocksHeld(gc, 2), "LockerAndUnlocker::testLocksHeld(gc, 2)", __FILE__, __LINE__);
        gc->Collect();
        gc->Collect();
// line 327 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::unlockLevel2(gc), "LockerAndUnlocker::unlockLevel2(gc)", __FILE__, __LINE__);
        gc->Collect();
        gc->Collect();
// line 330 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::testLocksHeld(gc, 1), "LockerAndUnlocker::testLocksHeld(gc, 1)", __FILE__, __LINE__);
        gc->Collect();
        gc->Collect();
// line 333 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::unlockLevel1(gc), "LockerAndUnlocker::unlockLevel1(gc)", __FILE__, __LINE__);

        // Bug 637695: be aware: conservative retention may foil verify below
        gc->Collect();
        gc->Collect();
// line 338 "ST_mmgc_basics.st"
verifyPass(LockerAndUnlocker::testLocksNotHeld(gc), "LockerAndUnlocker::testLocksNotHeld(gc)", __FILE__, __LINE__);

        delete gc;
    }

}
void ST_mmgc_basics::test15() {
    {
        GCConfig config;
        GC *testGC = new GC(GCHeap::GetGCHeap(), config);
        {
            MMGC_GCENTER(testGC);
            testGC->StartIncrementalMark();
            // self test for tricky GCRoot deletion logic
            // do this a bunch, idea is to try to hit GetItemAbove border edge cases
            //GCMarkStack& ms = testGC->m_incrementalWork;
            for(int i=0;i<10000;i++) {
                //GCRoot *fauxRoot = new GCRoot(testGC, new char[GC::kMarkItemSplitThreshold*2], GC::kMarkItemSplitThreshold*2);
                //testGC->MarkAllRoots();
                // tail of fauxRoot is on stack
                //uintptr_t sentinel = fauxRoot->GetMarkStackSentinelPointer();
                //if(sentinel) {
                //    const void* ptr;
                //    ms.Read_RootProtector(sentinel, ptr);
                //    %%verify ptr == fauxRoot
                //    uintptr_t tail = ms.GetItemAbove(sentinel);
                //    %%verify ms.GetEndAt(tail) == fauxRoot->End()
                //    %%verify sentinel != 0
                //}
                //delete [] (char*)fauxRoot->Get();
                //delete fauxRoot;
                //if(sentinel) {
                //    %%verify ms.P(sentinel) == GCMarkStack::kDeadItem
                //    %%verify ms.GetSentinel1TypeAt(ms.GetItemAbove(sentinel)) == GCMarkStack::kDeadItem
                //}
// line 372 "ST_mmgc_basics.st"
verifyPass(true, "true", __FILE__, __LINE__);
            }
            testGC->Mark();
            testGC->ClearMarkStack();
            testGC->ClearMarks();
        }
        delete testGC;
    }


}
void ST_mmgc_basics::test16() {
#ifdef MMGC_HEAP_GRAPH
    GCConfig config;
    GC *gc = new GC(GCHeap::GetGCHeap(), config);
    MMGC_GCENTER(gc);
    MyGCObject *mygcobject;
    mygcobject = (MyGCObject *)new (gc) MyGCObject();
    gc->addToBlacklist(mygcobject);
    gc->Collect();
    gc->removeFromBlacklist(mygcobject);
    delete gc;
#endif
// line 394 "ST_mmgc_basics.st"
verifyPass(true, "true", __FILE__, __LINE__);

}
void ST_mmgc_basics::test17() {
    MMGC_GCENTER(gc);
    MyGCObject *mygcobject;
    mygcobject = (MyGCObject *) new (gc) MyGCObject();
// line 400 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
    delete mygcobject;
// line 402 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
    gc->Collect();
// line 404 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
    MyGCLargeObject *mygclargeobject;
    mygclargeobject = (MyGCLargeObject *) new (gc) MyGCLargeObject();
// line 407 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
    delete mygclargeobject;
// line 409 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast(), "gc->GetBytesInUse() == gc->GetBytesInUseFast()", __FILE__, __LINE__);
    gc->Collect();
// line 411 "ST_mmgc_basics.st"
verifyPass(gc->GetBytesInUse() == gc->GetBytesInUseFast() , "gc->GetBytesInUse() == gc->GetBytesInUseFast() ", __FILE__, __LINE__);
     

}
void create_mmgc_basics(AvmCore* core) { new ST_mmgc_basics(core); }
}
}
#endif

// Generated from ST_mmgc_dependent.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 543560 - here we risk deleting an object that is still on the mark stack because
// of how we perform large-object splitting.  The setup is that user code that deletes the object
// gets to run after the first part of the large object has been popped off the mark stack
// but before the rest has been handled.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_dependent {
using namespace MMgc;

static const size_t nbytes = 16*1024*1024;

class DependentAllocHolder : public GCFinalizedObject {
public:

  DependentAllocHolder() {
    memory = (char*)FixedMalloc::GetFixedMalloc()->Alloc(nbytes);
    GC::GetGC(this)->SignalDependentAllocation(nbytes);
  }

  virtual ~DependentAllocHolder() {
    FixedMalloc::GetFixedMalloc()->Free(memory);
    memory = NULL;
    GC::GetGC(this)->SignalDependentDeallocation(nbytes);
  }
  private:
    char* memory;
};

class ST_mmgc_dependent : public Selftest {
public:
ST_mmgc_dependent(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
private:
    MMgc::GC *gc;

};
ST_mmgc_dependent::ST_mmgc_dependent(AvmCore* core)
    : Selftest(core, "mmgc", "dependent", ST_mmgc_dependent::ST_names,ST_mmgc_dependent::ST_explicits)
{}
const char* ST_mmgc_dependent::ST_names[] = {"dependent_alloc","dependent_memory_total","dependent_memory_unknown", NULL };
const bool ST_mmgc_dependent::ST_explicits[] = {false,false,false, false };
void ST_mmgc_dependent::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
}
}
void ST_mmgc_dependent::prologue() {
    GCConfig config;
    gc = new GC(GCHeap::GetGCHeap(), config);

}
void ST_mmgc_dependent::epilogue() {
    delete gc;

}
void ST_mmgc_dependent::test0() {
    size_t maxheap = 0;
    {
        MMGC_GCENTER(gc);

        int count = 100;
        for (int c=0; c<count; c++) {
            (void)(new (gc) DependentAllocHolder());
            size_t heapsize = gc->policy.blocksOwnedByGC() * GCHeap::kBlockSize;
            // printf("%lu\n", (unsigned long)heapsize);
            if (heapsize > maxheap)
                maxheap = heapsize;
        }
    }

    // This is tricky to get right but for this test the 16MB blocks will dominate
    // completely.  So assume that heap size must stay below L*2*16MB for the
    // L that applies at 32MB.

// line 68 "ST_mmgc_dependent.st"
verifyPass(size_t(gc->policy.queryLoadForHeapsize(double(2*nbytes)) * 2.0 * double(nbytes)) >= maxheap, "size_t(gc->policy.queryLoadForHeapsize(double(2*nbytes)) * 2.0 * double(nbytes)) >= maxheap", __FILE__, __LINE__);

}
void ST_mmgc_dependent::test1() {
#if defined VMCFG_TELEMETRY && defined AVMSHELL_BUILD
    size_t depMem_start,depMem_end;
    depMem_start = depMem_end = 0;
    MMgc::GC* gc = core->gc;

    // Check total dependent memory consistency
    for(int i = 0; i < MMgc::typeCount; i++)
        depMem_start += gc->getDependentMemory((MMgc::DependentMemoryType)i);
// line 79 "ST_mmgc_dependent.st"
verifyPass(depMem_start == gc->policy.dependentAllocation, "depMem_start == gc->policy.dependentAllocation", __FILE__, __LINE__);

    // Check byteArray type dependent memory
    avmshell::ShellCore* c = (avmshell::ShellCore*)core;
    avmshell::ShellToplevel* top = c->shell_toplevel;

    size_t byteArray_bytes1 = gc->getDependentMemory(MMgc::typeByteArray);
    ByteArrayObject* byteArray = top->byteArrayClass()->constructByteArray();
    byteArray->writeBoolean(false);
    byteArray->writeDouble(3.14);

    // Allocate known type dependent memory
    size_t byteArray_bytes2 = gc->getDependentMemory(MMgc::typeByteArray);
// line 92 "ST_mmgc_dependent.st"
verifyPass(byteArray_bytes2 > byteArray_bytes1, "byteArray_bytes2 > byteArray_bytes1", __FILE__, __LINE__);

    // Allocate unknown dependent memory
    DependentAllocHolder* obj = new (gc) DependentAllocHolder();

    size_t byteArray_bytes3 = gc->getDependentMemory(MMgc::typeByteArray);
// line 98 "ST_mmgc_dependent.st"
verifyPass(byteArray_bytes3 == byteArray_bytes2, "byteArray_bytes3 == byteArray_bytes2", __FILE__, __LINE__);
    byteArray->clear();
 
// line 101 "ST_mmgc_dependent.st"
verifyPass(gc->getDependentMemory(MMgc::typeByteArray) == byteArray_bytes1, "gc->getDependentMemory(MMgc::typeByteArray) == byteArray_bytes1", __FILE__, __LINE__);
    delete obj;

    // Consistency check
    for(int i = 0; i < MMgc::typeCount; i++)
        depMem_end += gc->getDependentMemory((MMgc::DependentMemoryType)i);
// line 107 "ST_mmgc_dependent.st"
verifyPass(depMem_end == gc->policy.dependentAllocation, "depMem_end == gc->policy.dependentAllocation", __FILE__, __LINE__);
// line 108 "ST_mmgc_dependent.st"
verifyPass(depMem_end == depMem_start, "depMem_end == depMem_start", __FILE__, __LINE__);

#if !defined DEBUG && !defined DEBUGGER
    // Get memory for out of bounds type
    // getDependentMemory has assert; skip in debug build
// line 113 "ST_mmgc_dependent.st"
verifyPass(gc->getDependentMemory(MMgc::typeCount) == 0, "gc->getDependentMemory(MMgc::typeCount) == 0", __FILE__, __LINE__);
#endif
// line 115 "ST_mmgc_dependent.st"
verifyPass(true, "true", __FILE__, __LINE__);
#endif

}
void ST_mmgc_dependent::test2() {
#if defined VMCFG_TELEMETRY && defined AVMSHELL_BUILD
    // Check unknown type dependent memory
    MMgc::GC* gc = core->gc;
    size_t unknownDependentMem_start = gc->getDependentMemory(MMgc::typeUnknown);
    DependentAllocHolder* obj = new (gc) DependentAllocHolder();
    size_t unknownDependentMem_end = gc->getDependentMemory(MMgc::typeUnknown);
// line 125 "ST_mmgc_dependent.st"
verifyPass((unknownDependentMem_end - unknownDependentMem_start) == nbytes, "(unknownDependentMem_end - unknownDependentMem_start) == nbytes", __FILE__, __LINE__);
    
    delete obj;
// line 128 "ST_mmgc_dependent.st"
verifyPass(unknownDependentMem_start == gc->getDependentMemory(MMgc::typeUnknown), "unknownDependentMem_start == gc->getDependentMemory(MMgc::typeUnknown)", __FILE__, __LINE__);
#else
// line 130 "ST_mmgc_dependent.st"
verifyPass(true, "true", __FILE__, __LINE__);
#endif


}
void create_mmgc_dependent(AvmCore* core) { new ST_mmgc_dependent(core); }
}
}
#endif

// Generated from ST_mmgc_exact.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_exact {

class Cthulhu : public MMgc::GCTraceableObject
{
public:
    static Cthulhu* create(MMgc::GC* gc) {
        return new (gc, MMgc::kExact) Cthulhu();
    }

    virtual bool gcTrace(MMgc::GC* gc, size_t cursor) {
        (void)gc;
        // Incorrectly say that there's more to do even when the object is small
        if (cursor == 0)
            return true;
        // Concede
        return false;
    }
};

// This test triggers a particular edge case in GC::SplitExactGCObject where
// a small object that returns 'true' from its gcTrace method is synchronously
// marked until the method returns 'false'; a 'true' return is only ever expected
// from the gcTrace methods of large objects.

class ST_mmgc_exact : public Selftest {
public:
ST_mmgc_exact(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
};
ST_mmgc_exact::ST_mmgc_exact(AvmCore* core)
    : Selftest(core, "mmgc", "exact", ST_mmgc_exact::ST_names,ST_mmgc_exact::ST_explicits)
{}
const char* ST_mmgc_exact::ST_names[] = {"IncorrectlySplitSmallObject", NULL };
const bool ST_mmgc_exact::ST_explicits[] = {false, false };
void ST_mmgc_exact::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_mmgc_exact::test0() {
    // Create an object that stays alive so that its tracer will be called
    MMgc::GCObjectLock* lock = core->gc->LockObject(Cthulhu::create(core->gc));
    core->gc->Collect();
    core->gc->Collect();
    core->gc->UnlockObject(lock);

// line 42 "ST_mmgc_exact.st"
verifyPass(true, "true", __FILE__, __LINE__);


}
void create_mmgc_exact(AvmCore* core) { new ST_mmgc_exact(core); }
}
}
#endif

// Generated from ST_mmgc_externalalloc.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_externalalloc {
using namespace MMgc;
class MyCallback : public MMgc::OOMCallback
{
public:
    MMgc::MemoryStatus status;

    MyCallback()
    {
        status = MMgc::GCHeap::GetGCHeap()->GetStatus();
        MMgc::GCHeap::GetGCHeap()->AddOOMCallback(this);
    }

    void memoryStatusChange(MMgc::MemoryStatus /*oldStatus*/, MMgc::MemoryStatus newStatus)
    {
        status = newStatus;
    }
};

class ST_mmgc_externalalloc : public Selftest {
public:
ST_mmgc_externalalloc(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
private:
    MyCallback *cb;

};
ST_mmgc_externalalloc::ST_mmgc_externalalloc(AvmCore* core)
    : Selftest(core, "mmgc", "externalalloc", ST_mmgc_externalalloc::ST_names,ST_mmgc_externalalloc::ST_explicits)
{}
const char* ST_mmgc_externalalloc::ST_names[] = {"externalAllocation", NULL };
const bool ST_mmgc_externalalloc::ST_explicits[] = {false, false };
void ST_mmgc_externalalloc::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_mmgc_externalalloc::prologue() {
    cb = new MyCallback();

}
void ST_mmgc_externalalloc::epilogue() {
    cb = NULL;

}
void ST_mmgc_externalalloc::test0() {
    MMGC_GCENTER(core->gc);
    size_t softlimit = GCHeap::GetGCHeap()->Config().heapSoftLimit;
    // Remove the heapSoftLimit, this should ensure that we are not in a MMgc::kMemSoftLimit state,
    // and hopefully we are in a kMemNormal state otherwise we are in a kMemAbort state and all bets are off.
    GCHeap::GetGCHeap()->Config().heapSoftLimit = 0;
// line 45 "ST_mmgc_externalalloc.st"
verifyPass(cb->status==MMgc::kMemNormal, "cb->status==MMgc::kMemNormal", __FILE__, __LINE__);
    GCHeap::GetGCHeap()->Config().heapSoftLimit = GCHeap::GetGCHeap()->GetTotalHeapSize();
    MMgc::GCHeap::SignalExternalAllocation(1024*1024);
// line 48 "ST_mmgc_externalalloc.st"
verifyPass(cb->status==MMgc::kMemSoftLimit, "cb->status==MMgc::kMemSoftLimit", __FILE__, __LINE__);
    MMgc::GCHeap::SignalExternalDeallocation(1024*1024);
// line 50 "ST_mmgc_externalalloc.st"
verifyPass(cb->status==MMgc::kMemNormal, "cb->status==MMgc::kMemNormal", __FILE__, __LINE__);
    GCHeap::GetGCHeap()->Config().heapSoftLimit = softlimit;
    softlimit = 0;



}
void create_mmgc_externalalloc(AvmCore* core) { new ST_mmgc_externalalloc(core); }
}
}
#endif

// Generated from ST_mmgc_finalize_uninit.st
// -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */

// Bugzilla 573737 - a throw from an argument to a constructor can
// cause an object to be allocated on the gc-heap before it has been
// fully initialized.  (In particular, its vtable could be missing.)
// Since finalizers use the virtual destructor method, a missing
// vtable is a problem.
//
// Its a little tricky to test this because the "order of evaluation
// to an operator new() to get memory and the evaluation of arguments
// to constructors is undefined"; see details below.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_finalize_uninit {

using namespace MMgc;

class D : public GCFinalizedObject
{
public:
    D(int dummyArgument) { (void)dummyArgument; }
    ~D() { ++finalized; }
    static int finalized_count() { return D::finalized; }
    static void reset_finalized_count() { finalized = 0; }
    // "usual" overload of placement new used in mmgc client code
    void * operator new(size_t size, GC *gc) {
        return GCFinalizedObject::operator new(size, gc);
    }
    // hack to explicitly order new-allocation + ctor-arg eval; see below
    // (but reallys its just good ol' placement new!)
    void * operator new(size_t size, GC *gc, void *raw) {
        (void)size; (void)gc;
        return raw;
    }
private:
    static int finalized;
};

/*static*/
int D::finalized;

int deathValue(AvmCore *core)
{
    core->throwAtom(atomFromIntptrValue(1)); /* won't return */

    return 0; /* silence compiler warnings */
}

// Test checks that finalizers themselves have not broken; here,
// constructor argument subexpression evaluates cleanly.
class ST_mmgc_finalize_uninit : public Selftest {
public:
ST_mmgc_finalize_uninit(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
};
ST_mmgc_finalize_uninit::ST_mmgc_finalize_uninit(AvmCore* core)
    : Selftest(core, "mmgc", "finalize_uninit", ST_mmgc_finalize_uninit::ST_names,ST_mmgc_finalize_uninit::ST_explicits)
{}
const char* ST_mmgc_finalize_uninit::ST_names[] = {"check_finalizers_still_work","original_death","desugared_check_finalizers_still_work","desugared_death", NULL };
const bool ST_mmgc_finalize_uninit::ST_explicits[] = {false,false,false,false, false };
void ST_mmgc_finalize_uninit::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
}
}
void ST_mmgc_finalize_uninit::test0() {
{
    D::reset_finalized_count();
    D* d;
    int i;

    // loop to alloc many (and subsequently reclaim >=expected percentage)
    for (i = 0; i < 100; i++) {
        d = new (core->gc) D(1);
    }
    (void) d;

    core->gc->Collect(); // finish any prior incremental work ...
    core->gc->Collect(); // ... and ensure we got fresh + complete gc.

    // printf("D::finalized_count(): %d\n", D::finalized_count());

// line 75 "ST_mmgc_finalize_uninit.st"
verifyPass((D::finalized_count() > 90), "(D::finalized_count() > 90)", __FILE__, __LINE__);
}

// Test illustrates of the kind of code that exposed the original bug;
// here, constructor argument subexpression throws.
}
void ST_mmgc_finalize_uninit::test1() {
{
    D* d;
    volatile int i;

    // Here, constructor argument subexpression throws

    // Just one allocation attempt alone would risk false retention of
    // intermediate values, so loop a bit to ensure that *some* D's,
    // if allocated at all, will be considered garbage.
    for (i = 0; i < 5; i++) {
        TRY (core, kCatchAction_Ignore) {
            d = new (core->gc) D(deathValue(core));
        }  CATCH (Exception *e) {
            (void)e;
        }
        END_CATCH
        END_TRY
    }
    (void) d;

    // if things go badly, one of the collections below will segfault
    // during finalization.
    core->gc->Collect();
    core->gc->Collect();

    // (not dying is passing.)
// line 107 "ST_mmgc_finalize_uninit.st"
verifyPass(true, "true", __FILE__, __LINE__);
}

// C++ standard says "The order of evaluation to an operator new() to
// get memory and the evaluation of arguments to constructors is
// undefined."
//
// Unfortunately, it is difficult to directly express the particular
// order of evaluation that exposes the bug in question, because
// allocation and construction are tied together.
//
// So, here we manually decompose the tests above to control
// evaluation order of operator new() and constructor arguments, to
// express suitable evil (namely: allocation; args eval; construction)
// for selftest.
//
// The desugaring iteself is:
// desugar[[ new (gc-exp) D(arg-exp) ]]
// ==> mem = D::operator new(sizeof(D), arg), new (gc-exp, mem) D(arg-exp)

// Test illustrates desugaring is "sound"; keep in sync with
// check_finalizers_still_work above.
}
void ST_mmgc_finalize_uninit::test2() {
{
    D::reset_finalized_count();
    D* d;
    int i;

    // loop to alloc many (and subsequently reclaim >=expected percentage)
    for (i = 0; i < 100; i++) {
        // d = new (core->gc) D(s);
        void *mem = D::operator new(sizeof(D), core->gc);
        d = new (core->gc, mem) D(1);
    }
    (void) d;

    core->gc->Collect(); // finish any prior incremental work ...
    core->gc->Collect(); // ... and ensure we got fresh + complete gc.

    // printf("D::finalized_count(): %d\n", D::finalized_count());

// line 148 "ST_mmgc_finalize_uninit.st"
verifyPass((D::finalized_count() > 90), "(D::finalized_count() > 90)", __FILE__, __LINE__);
}


// Test forces evil order of evaluation via desugaring of
// construction; keep in sync with original_death above.
}
void ST_mmgc_finalize_uninit::test3() {
{
    D* d;
    volatile int i;

    // Here, constructor argument subexpression throws

    // Just one allocation attempt alone would risk false retention of
    // intermediate values, so loop a bit to ensure that *some* D's,
    // which are forcibly allocated here, will be considered garbage.
    for (i = 0; i < 5; i++) {
        TRY (core, kCatchAction_Ignore) {
            // d = new (core->gc) D(deathValue());
            void *mem = D::operator new(sizeof(D), core->gc);
            d = new (core->gc, mem) D(deathValue(core));
        }  CATCH (Exception *e) {
            (void)e;
        }
        END_CATCH
        END_TRY
    }
    (void) d;

    // if things go badly, one of the collections below will segfault
    // during finalization.
    core->gc->Collect();
    core->gc->Collect();

    // (not dying is passing.)
// line 183 "ST_mmgc_finalize_uninit.st"
verifyPass(true, "true", __FILE__, __LINE__);
}

}
void create_mmgc_finalize_uninit(AvmCore* core) { new ST_mmgc_finalize_uninit(core); }
}
}
#endif

// Generated from ST_mmgc_fixedmalloc_findbeginning.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 663508: Add FixedMalloc::FindBeginning

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_fixedmalloc_findbeginning {
using namespace MMgc;

class ST_mmgc_fixedmalloc_findbeginning : public Selftest {
public:
ST_mmgc_fixedmalloc_findbeginning(AvmCore* core);
virtual void run(int n);
virtual void prologue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
void test8();
void test9();
void test10();
void test11();

    MMgc::FixedMalloc *fm;

    // Allocates object of size sz and tests FixedMalloc::FindBeginning
    // at various addresses within the allocated object.  The sampled
    // addresses are meant to cover the following interesting edge
    // cases: at or near the object's start, the middle of the object,
    // and at or near the object's end.
    //
    // If all the tests successively identify the object's start, then
    // returns 0.  Otherwise returns a numeric code identifying which
    // tests failed.
    int allocateVerifyAndFree(size_t sz)
    {
        int retval = 0;
        (void)sz;

        char *obj = (char*)fm->Alloc(sz);

        retval |= checkLookups(obj, obj, sz);
        retval = retval << 2;
        if (sz > 1) retval |= checkLookups(obj+1, obj, sz);
        retval = retval << 2;
        if (sz > 3) retval |= checkLookups(obj+3, obj, sz);
        retval = retval << 2;
        retval |= checkLookups(obj+sz/2, obj, sz);
        retval = retval << 2;
        retval |= checkLookups(obj+sz-1, obj, sz);
        retval = retval << 2;

        fm->Free(obj);

        return retval;
    }

    // Returns 0 if both test of FixedMalloc::FindBeginning and
    // FixedMalloc::FindBeginningAndSize pass.
    // Returns 1 if the first test (of FindBeginning) fails.
    // Returns 2 if the second test (of FindBeginningAndSize) fails.
    int checkLookups(const void* probe, const void* realStart, size_t sz)
    {
        int retval = 0;
        const void* begin_recv;
        size_t size_recv;
        size_t roundup_actual_size;

        if (sz <= (size_t)FixedMalloc::kLargestAlloc)
            roundup_actual_size = fm->FindAllocatorForSize(sz)->GetItemSize();
        else
            roundup_actual_size =
                roundUp(sz + DebugSize(), GCHeap::kBlockSize) - DebugSize();

        if (fm->FindBeginning(probe) != realStart)
            retval |= 1;
        if (!fm->FindBeginningAndSize(probe, begin_recv, size_recv) ||
            (begin_recv != realStart) ||
            (size_recv != roundup_actual_size))
            retval |= 3;

        return retval;
    }

    size_t roundUp(size_t s, size_t inc) {
        return (((s + inc - 1) / inc) * inc);
    }

};
ST_mmgc_fixedmalloc_findbeginning::ST_mmgc_fixedmalloc_findbeginning(AvmCore* core)
    : Selftest(core, "mmgc", "fixedmalloc_findbeginning", ST_mmgc_fixedmalloc_findbeginning::ST_names,ST_mmgc_fixedmalloc_findbeginning::ST_explicits)
{}
const char* ST_mmgc_fixedmalloc_findbeginning::ST_names[] = {"findbeginnings_small0","findbeginnings_small1","findbeginnings_small2","findbeginnings_small3","findbeginnings_almost_large1","findbeginnings_almost_large2","findbeginnings_large","findbeginnings_almost_multiblock1","findbeginnings_almost_multiblock2","findbeginnings_barely_multiblock","findbeginnings_multiblock_two","findbeginnings_multiblock_ten", NULL };
const bool ST_mmgc_fixedmalloc_findbeginning::ST_explicits[] = {false,false,false,false,false,false,false,false,false,false,false,false, false };
void ST_mmgc_fixedmalloc_findbeginning::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
case 5: test5(); return;
case 6: test6(); return;
case 7: test7(); return;
case 8: test8(); return;
case 9: test9(); return;
case 10: test10(); return;
case 11: test11(); return;
}
}
void ST_mmgc_fixedmalloc_findbeginning::prologue() {
    fm = MMgc::FixedMalloc::GetFixedMalloc();

}

void ST_mmgc_fixedmalloc_findbeginning::test0() {
    {
        size_t sz = FixedMalloc::kSizeClasses[0];
// line 91 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test1() {
    {
        size_t sz = FixedMalloc::kSizeClasses[1];
// line 98 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test2() {
    {
        size_t sz = FixedMalloc::kSizeClasses[2];
// line 105 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test3() {
    {
        size_t sz = FixedMalloc::kSizeClasses[3];
// line 112 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test4() {
    {
        size_t sz = FixedMalloc::kLargestAlloc - 1;
        sz = sz - DebugSize();
// line 120 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 123 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test5() {
    {
        size_t sz = FixedMalloc::kLargestAlloc;
        sz = sz - DebugSize();
// line 131 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 134 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test6() {
    {
        size_t sz = FixedMalloc::kLargestAlloc+1;
        sz = sz - DebugSize();
// line 142 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 145 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test7() {
    {
        size_t sz = GCHeap::kBlockSize-1;
        sz = sz - DebugSize();
// line 153 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 156 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test8() {
    {
        size_t sz = GCHeap::kBlockSize;
        sz = sz - DebugSize();
// line 164 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 167 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test9() {
    {
        size_t sz = GCHeap::kBlockSize+1;
        sz = sz - DebugSize();
// line 175 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 178 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test10() {
    {
        size_t sz = GCHeap::kBlockSize*2;
        sz = sz - DebugSize();
// line 186 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 189 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void ST_mmgc_fixedmalloc_findbeginning::test11() {
    {
        size_t sz = GCHeap::kBlockSize*10;
        sz = sz - DebugSize();
// line 197 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
        sz = sz + DebugSize();
// line 200 "ST_mmgc_fixedmalloc_findbeginning.st"
verifyPass(allocateVerifyAndFree(sz) == 0, "allocateVerifyAndFree(sz) == 0", __FILE__, __LINE__);
              ;
    }

}
void create_mmgc_fixedmalloc_findbeginning(AvmCore* core) { new ST_mmgc_fixedmalloc_findbeginning(core); }
}
}
#endif

// Generated from ST_mmgc_gcheap.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_gcheap {
class ST_mmgc_gcheap : public Selftest {
public:
ST_mmgc_gcheap(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
};
ST_mmgc_gcheap::ST_mmgc_gcheap(AvmCore* core)
    : Selftest(core, "mmgc", "gcheap", ST_mmgc_gcheap::ST_names,ST_mmgc_gcheap::ST_explicits)
{}
const char* ST_mmgc_gcheap::ST_names[] = {"largeAlloc","largeAllocAlignment", NULL };
const bool ST_mmgc_gcheap::ST_explicits[] = {false,false, false };
void ST_mmgc_gcheap::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
}
}
using namespace MMgc;

void ST_mmgc_gcheap::test0() {
       GCHeap *heap = GCHeap::GetGCHeap();
       for(int i=1;i<4;i++) {
          void *item = heap->Alloc(GCHeap::kOSAllocThreshold*i);
// line 17 "ST_mmgc_gcheap.st"
verifyPass(heap->Size(item) == GCHeap::kOSAllocThreshold*i, "heap->Size(item) == GCHeap::kOSAllocThreshold*i", __FILE__, __LINE__);
          heap->Free(item);
       }
// line 20 "ST_mmgc_gcheap.st"
verifyPass(true, "true", __FILE__, __LINE__);

}
void ST_mmgc_gcheap::test1() {
       GCHeap *heap = GCHeap::GetGCHeap();
       for(int i=1;i<10;i++) {
          void *item = heap->Alloc(GCHeap::kOSAllocThreshold*i, GCHeap::flags_Alloc, 1<<i);
// line 26 "ST_mmgc_gcheap.st"
verifyPass(heap->Size(item) == GCHeap::kOSAllocThreshold*i, "heap->Size(item) == GCHeap::kOSAllocThreshold*i", __FILE__, __LINE__);
// line 27 "ST_mmgc_gcheap.st"
verifyPass(uintptr_t(((GCHeap::kBlockSize<<(i-1))-1) & uintptr_t(item)) == 0, "uintptr_t(((GCHeap::kBlockSize<<(i-1))-1) & uintptr_t(item)) == 0", __FILE__, __LINE__);
          heap->Free(item);
       }


}
void create_mmgc_gcheap(AvmCore* core) { new ST_mmgc_gcheap(core); }
}
}
#endif

// Generated from ST_mmgc_gcoption.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_gcoption {
using namespace MMgc;

class ST_mmgc_gcoption : public Selftest {
public:
ST_mmgc_gcoption(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
    bool m_ret;
    bool m_wrong;
    GCHeap *m_heap;
    GCHeapConfig m_config_orig;
    bool isParamOption(const char* line) {
        return m_heap->config.IsGCOptionWithParam(line);
    }
    bool notParamOption(const char* line) {
        return !isParamOption(line);
    }
    bool approxEqual(double x, double y) {
        double delta1 = x - y;
        // abs() does not produce correct results at e.g. DBL_MAX.
        double delta2 = (delta1 > 0) ? delta1 : -delta1;
        return (delta2 < 0.0001);
    }
    void parseApply(const char* line, const char* optExtra=0)
    {
        m_ret = m_heap->config.ParseAndApplyOption(line, m_wrong, optExtra);
    }
    bool parsedCorrectly() {
        return m_ret && !m_wrong;
    }
    bool gcoptionButIncorrectFormat() {
        return m_ret && m_wrong;
    }

    void saveOrigHeapConfig() {
        memcpy(&m_config_orig, &m_heap->config, sizeof(GCHeapConfig));
    }

    void restoreHeapConfig() {
        memcpy(&m_heap->config, &m_config_orig, sizeof(GCHeapConfig));
    }

    bool configUnchanged() {
        const char* c1 = (const char*)&m_heap->config;
        const char* c2 = (const char*)&m_config_orig;
        bool noChangeSeen = true;
        for (size_t i=0; i < sizeof(GCHeapConfig); i++) {
            if (*c1 != *c2)
                noChangeSeen = false;
        }
        return noChangeSeen;
    }

};
ST_mmgc_gcoption::ST_mmgc_gcoption(AvmCore* core)
    : Selftest(core, "mmgc", "gcoption", ST_mmgc_gcoption::ST_names,ST_mmgc_gcoption::ST_explicits)
{}
const char* ST_mmgc_gcoption::ST_names[] = {"detect_parameterized_options","parse_memstats","parse_memlimit","parse_gcbehavior_gcsummary_eagersweep","parse_load_gcwork", NULL };
const bool ST_mmgc_gcoption::ST_explicits[] = {false,false,false,false,false, false };
void ST_mmgc_gcoption::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
}
}
void ST_mmgc_gcoption::prologue() {
{
    m_heap = GCHeap::GetGCHeap();
    saveOrigHeapConfig();
}

}
void ST_mmgc_gcoption::epilogue() {
{
    restoreHeapConfig();
}

}
void ST_mmgc_gcoption::test0() {
{
// line 75 "ST_mmgc_gcoption.st"
verifyPass(isParamOption("-memlimit"), "isParamOption(\"-memlimit\")", __FILE__, __LINE__);
// line 76 "ST_mmgc_gcoption.st"
verifyPass(isParamOption("-load"), "isParamOption(\"-load\")", __FILE__, __LINE__);
// line 77 "ST_mmgc_gcoption.st"
verifyPass(isParamOption("-loadCeiling"), "isParamOption(\"-loadCeiling\")", __FILE__, __LINE__);
// line 78 "ST_mmgc_gcoption.st"
verifyPass(isParamOption("-gcwork"), "isParamOption(\"-gcwork\")", __FILE__, __LINE__);
// line 79 "ST_mmgc_gcoption.st"
verifyPass(isParamOption("-gcstack"), "isParamOption(\"-gcstack\")", __FILE__, __LINE__);

// line 81 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-memlimit=10"), "notParamOption(\"-memlimit=10\")", __FILE__, __LINE__);
// line 82 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-load 1.5"), "notParamOption(\"-load 1.5\")", __FILE__, __LINE__);
// line 83 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-loadCeiling 1.5"), "notParamOption(\"-loadCeiling 1.5\")", __FILE__, __LINE__);
// line 84 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-gcwork 1.5"), "notParamOption(\"-gcwork 1.5\")", __FILE__, __LINE__);
// line 85 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-gcstack 10"), "notParamOption(\"-gcstack 10\")", __FILE__, __LINE__);

// line 87 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-not_an_option_and_never_will_be"), "notParamOption(\"-not_an_option_and_never_will_be\")", __FILE__, __LINE__);
// line 88 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-not_an_option_and_never_will_be 10"), "notParamOption(\"-not_an_option_and_never_will_be 10\")", __FILE__, __LINE__);
// line 89 "ST_mmgc_gcoption.st"
verifyPass(notParamOption("-not_an_option_and_never_will_be=10"), "notParamOption(\"-not_an_option_and_never_will_be=10\")", __FILE__, __LINE__);
          ;
}

}
void ST_mmgc_gcoption::test1() {
{
    // sanity checks:
    // - make sure our configUnchanged check is sane
    // - make sure our restoreHeapConfig works.
// line 98 "ST_mmgc_gcoption.st"
verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
    memset(&m_heap->config, 0xfe, sizeof(GCHeapConfig));
// line 100 "ST_mmgc_gcoption.st"
verifyPass(!configUnchanged(), "!configUnchanged()", __FILE__, __LINE__);
    restoreHeapConfig();
// line 102 "ST_mmgc_gcoption.st"
verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
          ;

    parseApply("-memstats");
// line 106 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 107 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.gcstats && m_heap->config.autoGCStats, "m_heap->config.gcstats && m_heap->config.autoGCStats", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-memstats-verbose");
// line 112 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 113 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.gcstats && m_heap->config.autoGCStats && m_heap->config.verbose, "m_heap->config.gcstats && m_heap->config.autoGCStats && m_heap->config.verbose", __FILE__, __LINE__);
          ;
    restoreHeapConfig();
}
}
void ST_mmgc_gcoption::test2() {
{
    parseApply("-memlimit   10");
// line 120 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 121 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.heapLimit == 10, "m_heap->config.heapLimit == 10", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-memlimit=11");
// line 126 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 127 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.heapLimit == 11, "m_heap->config.heapLimit == 11", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-memlimit = 12");
// line 132 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 133 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.heapLimit == 12, "m_heap->config.heapLimit == 12", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-memlimit");
// line 138 "ST_mmgc_gcoption.st"
verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
// line 139 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.heapLimit == m_config_orig.heapLimit, "m_heap->config.heapLimit == m_config_orig.heapLimit", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-memlimit", "13");
// line 144 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 145 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.heapLimit == 13, "m_heap->config.heapLimit == 13", __FILE__, __LINE__);
          ;
    restoreHeapConfig();
}
}
void ST_mmgc_gcoption::test3() {
{
#ifdef MMGC_POLICY_PROFILING
    parseApply("-gcbehavior");
// line 153 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 154 "ST_mmgc_gcoption.st"
verifyPass((m_heap->config.gcbehavior == 2), "(m_heap->config.gcbehavior == 2)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-gcsummary");
// line 159 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 160 "ST_mmgc_gcoption.st"
verifyPass((m_heap->config.gcbehavior == 1), "(m_heap->config.gcbehavior == 1)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();
#endif

    parseApply("-eagersweep");
// line 166 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 167 "ST_mmgc_gcoption.st"
verifyPass(m_heap->config.eagerSweeping, "m_heap->config.eagerSweeping", __FILE__, __LINE__);
          ;
    restoreHeapConfig();
}
}
void ST_mmgc_gcoption::test4() {
{
    parseApply("-load 7.0");
// line 174 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 175 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[0], 7.0), "approxEqual(m_heap->config.gcLoad[0], 7.0)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    // test load with '<space><param>'
    parseApply("-load 6.0,10,5.0");
// line 181 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 182 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[0], 6.0), "approxEqual(m_heap->config.gcLoad[0], 6.0)", __FILE__, __LINE__);
// line 183 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 10.0), "approxEqual(m_heap->config.gcLoadCutoff[0], 10.0)", __FILE__, __LINE__);
// line 184 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[1], 5.0), "approxEqual(m_heap->config.gcLoad[1], 5.0)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    // test load with separate <param>
    parseApply("-load", "8.0,20.5,7.0");
// line 190 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 191 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[0], 8.0), "approxEqual(m_heap->config.gcLoad[0], 8.0)", __FILE__, __LINE__);
// line 192 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 20.5), "approxEqual(m_heap->config.gcLoadCutoff[0], 20.5)", __FILE__, __LINE__);
// line 193 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[1], 7.0), "approxEqual(m_heap->config.gcLoad[1], 7.0)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    // test load with '=<param>'
    parseApply("-load=10.0,30.5,9.0");
// line 199 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 200 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[0], 10.0), "approxEqual(m_heap->config.gcLoad[0], 10.0)", __FILE__, __LINE__);
// line 201 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 30.5), "approxEqual(m_heap->config.gcLoadCutoff[0], 30.5)", __FILE__, __LINE__);
// line 202 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[1], 9.0), "approxEqual(m_heap->config.gcLoad[1], 9.0)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    // Max load pairs is 7
    parseApply("-load 1.5,1.5,2,2,3,3,4,4,5,5,6,6,7,7,8,8");
// line 208 "ST_mmgc_gcoption.st"
verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
// line 209 "ST_mmgc_gcoption.st"
verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
    restoreHeapConfig();

    // Ensure that the last load value is ignored
    parseApply("-load=10.0,30.0,9.0,60.0");
// line 214 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 215 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[0], 10.0), "approxEqual(m_heap->config.gcLoad[0], 10.0)", __FILE__, __LINE__);
// line 216 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoadCutoff[0], 30.0), "approxEqual(m_heap->config.gcLoadCutoff[0], 30.0)", __FILE__, __LINE__);
// line 217 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoad[1], 9.0), "approxEqual(m_heap->config.gcLoad[1], 9.0)", __FILE__, __LINE__);
// line 218 "ST_mmgc_gcoption.st"
verifyPass(!approxEqual(m_heap->config.gcLoadCutoff[1], 60.0), "!approxEqual(m_heap->config.gcLoadCutoff[1], 60.0)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-load");
// line 223 "ST_mmgc_gcoption.st"
verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
// line 224 "ST_mmgc_gcoption.st"
verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    // L (load) must be > 1
    parseApply("-load 1,30");
// line 230 "ST_mmgc_gcoption.st"
verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
// line 231 "ST_mmgc_gcoption.st"
verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-load badvalue");
// line 236 "ST_mmgc_gcoption.st"
verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
// line 237 "ST_mmgc_gcoption.st"
verifyPass(configUnchanged(), "configUnchanged()", __FILE__, __LINE__);
          ;
    restoreHeapConfig();


    parseApply("-loadCeiling 11.5");
// line 243 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 244 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcLoadCeiling, 11.5), "approxEqual(m_heap->config.gcLoadCeiling, 11.5)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-gcwork 12.5");
// line 249 "ST_mmgc_gcoption.st"
verifyPass(gcoptionButIncorrectFormat(), "gcoptionButIncorrectFormat()", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-gcwork 0.123456");
// line 254 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 255 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcEfficiency, .123456), "approxEqual(m_heap->config.gcEfficiency, .123456)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-gcwork=0.23456");
// line 260 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 261 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcEfficiency, .23456), "approxEqual(m_heap->config.gcEfficiency, .23456)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

    parseApply("-gcwork", "0.3456");
// line 266 "ST_mmgc_gcoption.st"
verifyPass(parsedCorrectly(), "parsedCorrectly()", __FILE__, __LINE__);
// line 267 "ST_mmgc_gcoption.st"
verifyPass(approxEqual(m_heap->config.gcEfficiency, .3456), "approxEqual(m_heap->config.gcEfficiency, .3456)", __FILE__, __LINE__);
          ;
    restoreHeapConfig();

}

}
void create_mmgc_gcoption(AvmCore* core) { new ST_mmgc_gcoption(core); }
}
}
#endif

// Generated from ST_mmgc_mmfx_array.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_mmfx_array {
class ST_mmgc_mmfx_array : public Selftest {
public:
ST_mmgc_mmfx_array(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
};
ST_mmgc_mmfx_array::ST_mmgc_mmfx_array(AvmCore* core)
    : Selftest(core, "mmgc", "mmfx_array", ST_mmgc_mmfx_array::ST_names,ST_mmgc_mmfx_array::ST_explicits)
{}
const char* ST_mmgc_mmfx_array::ST_names[] = {"mmfx_new_array_oom","mmfx_new_array_opts_canFail","mmfx_new_array_opts_oom", NULL };
const bool ST_mmgc_mmfx_array::ST_explicits[] = {true,true,true, false };
void ST_mmgc_mmfx_array::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
}
}
using namespace MMgc;

// There are different failure modes.
// 1) if you call mmfx_new_array() it can OOM:
//     -> it should OOM and shutdown
// 2) if you call mmfx_new_array_opts(canFail) and it OOMs:
//     -> it should return NULL and NOT OOM
// 3) if you call mmfx_new_aray_opts() without the canFail flag:
//     -> it should OOM and shutdown


void ST_mmgc_mmfx_array::test0() {
    // This will cause an OOM abort and exit, run with -memlimit 1024
    int* m_ints = mmfx_new_array(int, 1048576);
    mmfx_delete_array(m_ints);
    m_ints = NULL;
// line 27 "ST_mmgc_mmfx_array.st"
verifyPass(false, "false", __FILE__, __LINE__);

}
void ST_mmgc_mmfx_array::test1() {
    // This should fail and return NULL, run with -memlimit 1024
    int* m_ints = mmfx_new_array_opt(int, 1048576, MMgc::kCanFail);
// line 32 "ST_mmgc_mmfx_array.st"
verifyPass(m_ints == NULL, "m_ints == NULL", __FILE__, __LINE__);
    mmfx_delete_array(m_ints);
    m_ints = NULL;

}
void ST_mmgc_mmfx_array::test2() {
    // This will cause an OOM abort and exit, run with -memlimit 1024
    int* m_ints = mmfx_new_array_opt(int, 1048576, MMgc::kZero);
    mmfx_delete_array(m_ints);
    m_ints = NULL;
// line 41 "ST_mmgc_mmfx_array.st"
verifyPass(false, "false", __FILE__, __LINE__);



}
void create_mmgc_mmfx_array(AvmCore* core) { new ST_mmgc_mmfx_array(core); }
}
}
#endif

// Generated from ST_mmgc_threads.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if defined VMCFG_WORKERTHREADS
namespace avmplus {
namespace ST_mmgc_threads {
class ST_mmgc_threads : public Selftest {
public:
ST_mmgc_threads(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();

private:
    MMgc::GC *gc;
    MMgc::FixedAlloc *fa;
    MMgc::FixedMalloc *fm;
    bool waiting;
    bool result;
    bool isDead;
    pthread_t pthread;
    pthread_mutex_t pmutex;
    pthread_cond_t pcond;

    static void* slaveRunner(void *arg)
    {
        ((ST_mmgc_threads*)arg)->slaveRun();
        return NULL;
    }

    void slaveRun()
    {
        wait();
        {
      MMGC_ENTER_VOID;
         MMGC_GCENTER(gc);
         result &= !isDead;
         gc->ReapZCT();
         result &= !isDead;
         gc->Collect();
         result &= !isDead;
        }
        kick();
    }

    void startSlave()
    {
       pthread_create(&pthread, NULL, slaveRunner, this);
    }

    void kick()
    {
        pthread_mutex_lock (&pmutex);
        while(!waiting) {
            pthread_mutex_unlock (&pmutex);
            usleep(100);
            pthread_mutex_lock (&pmutex);
        }
        pthread_cond_signal (&pcond);
        while(waiting) {
            pthread_mutex_unlock (&pmutex);
            usleep(100);
            pthread_mutex_lock (&pmutex);
        }
        pthread_mutex_unlock (&pmutex);
    }

    void wait()
    {
        pthread_mutex_lock (&pmutex);
        GCAssert(waiting == false);
        waiting = true;
        pthread_cond_wait (&pcond, &pmutex);
        waiting = false;
        pthread_mutex_unlock (&pmutex);
    }

    static void kickAndWait(void* arg)
    {
        ST_mmgc_threads* self = (ST_mmgc_threads*)arg;
        self->kick();
        self->wait();
    }

};
ST_mmgc_threads::ST_mmgc_threads(AvmCore* core)
    : Selftest(core, "mmgc", "threads", ST_mmgc_threads::ST_names,ST_mmgc_threads::ST_explicits)
{}
const char* ST_mmgc_threads::ST_names[] = {"mmgc_gc_root_thread", NULL };
const bool ST_mmgc_threads::ST_explicits[] = {false, false };
void ST_mmgc_threads::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_mmgc_threads::prologue() {
    MMgc::GCConfig config;
    gc=new MMgc::GC(MMgc::GCHeap::GetGCHeap(), config);
    if (gc==NULL) {
        MMgc::GCHeap::Init();
        gc=new MMgc::GC(MMgc::GCHeap::GetGCHeap(), config);
    }
    pthread_mutex_init(&pmutex, NULL);
    pthread_cond_init(&pcond, NULL);
    result = true;
    isDead = false;
    waiting = false;

}
void ST_mmgc_threads::epilogue() {
    pthread_mutex_destroy(&pmutex);
    pthread_cond_destroy(&pcond);
    delete gc;

}
using namespace MMgc;

class RCObjectNotifier : public RCObject
{
public:
        RCObjectNotifier(bool *isDead) : isDead(isDead) {}
        ~RCObjectNotifier() { *isDead = true; isDead = NULL; }
        bool *isDead;
};

void ST_mmgc_threads::test0() {
       startSlave();
       MMGC_GCENTER(gc);
       RCObjectNotifier *obj = new (gc) RCObjectNotifier(&isDead);
       {
          gc->CreateRootFromCurrentStack(kickAndWait, this);
       }

// line 122 "ST_mmgc_threads.st"
verifyPass(result, "result", __FILE__, __LINE__);

// line 124 "ST_mmgc_threads.st"
verifyPass(!isDead, "!isDead", __FILE__, __LINE__);
       gc->ReapZCT();
// line 126 "ST_mmgc_threads.st"
verifyPass(!isDead, "!isDead", __FILE__, __LINE__);
       gc->Collect();
// line 128 "ST_mmgc_threads.st"
verifyPass(!isDead, "!isDead", __FILE__, __LINE__);

       pthread_join(pthread, NULL);

       printf("Ignore this: %d\n", *obj->isDead);

}
void create_mmgc_threads(AvmCore* core) { new ST_mmgc_threads(core); }
}
}
#endif
#endif

// Generated from ST_mmgc_weakref.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_mmgc_weakref {
using namespace MMgc;

class C : public GCFinalizedObject
{
public:
    C(int key) : key(key) {}
    ~C() { key = -1; }
    int key;
    GCMember<C> next;
};

class MyCallback : public GCCallback
{
public:
    MyCallback(GC* gc, GCWeakRef** refs, C** objs, int n)
        : GCCallback(gc)
        , refs(refs)
        , objs(objs)
        , n(n)
    {
    }

    virtual void presweep() {
    for ( int i=1 ; i < 1000 ; i+=2 )
        objs[i]->next = (C*)(void *)(refs[i-1]->get());
    }

private:
    GCWeakRef** refs;
    C** objs;
    int n;
};

class D : public GCFinalizedObject
{
public:
    ~D() { GC::GetWeakRef(this); }
};

class ST_mmgc_weakref : public Selftest {
public:
ST_mmgc_weakref(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
};
ST_mmgc_weakref::ST_mmgc_weakref(AvmCore* core)
    : Selftest(core, "mmgc", "weakref", ST_mmgc_weakref::ST_names,ST_mmgc_weakref::ST_explicits)
{}
const char* ST_mmgc_weakref::ST_names[] = {"unmarked_object_presweep","unmarked_object_finalize", NULL };
const bool ST_mmgc_weakref::ST_explicits[] = {false,true, false };
void ST_mmgc_weakref::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
}
}
void ST_mmgc_weakref::test0() {

  // Bugzilla 572331 - it's possible for a weak reference to yield up a pointer to an unmarked
  // object in a presweep handler, and for that pointer to be stored into the heap even with
  // a WB macro, without the barrier triggering.

{
    GC* gc = core->gc;

    // Stack allocated storage, so automatically these arrays are roots

    GCWeakRef* refs[1000];
    C* objs[1000];

    // Create weak and strong references to 1000 objects

    for ( int i=0 ; i < 1000 ; i++ ) {
        objs[i] = new (gc) C(i);
        refs[i] = objs[i]->GetWeakRef();
    }

    // Get the collector into a reasonable state.

    gc->Collect();
    gc->Collect();

    // Remove the even-numbered strong refs.

    for ( int i=0 ; i < 1000 ; i+=2 )
        objs[i] = NULL;

    // Introduce mischief.  The presweep callback will extract
    // pointers from the even-numbered weak refs and insert them into
    // the objects in the odd-numbered slots (which are strongly
    // held).  Most of the objects referenced from the even-numbered
    // weak refs should be weakly held and unmarked.  We hope to catch
    // the collector picking up an unmarked object.

    MyCallback* cb = new MyCallback(gc, refs, objs, 1000);

    // Now trigger the collector again.

    gc->Collect();

    // Prevent more mischief from happening.

    delete cb;

    // Now reference all the odd-numbered objects and check the
    // integrity of their 'next' objects.  There's a chance this may
    // crash.

    for ( int i=1 ; i < 1000 ; i+= 2 ) {
// line 104 "ST_mmgc_weakref.st"
verifyPass(objs[i]->next->key == i-1, "objs[i]->next->key == i-1", __FILE__, __LINE__);
    }

    // Clean up
    VMPI_memset(refs, 0, sizeof(refs));
    VMPI_memset(objs, 0, sizeof(objs));
}

}
void ST_mmgc_weakref::test1() {

  // Bugzilla 647155 - ditto as the previous test, but now it's the object's destructor that tries
  // to store a pointer to an unmarked object (in this case the object itself) into a weak ref.
  // This will assert in debug builds, so the test is marked "explicit" for that reason: in a
  // debug build we want to verify that the assert is hit, in a release build we want to verify that
  // the test does not crash.
  
{
    GC* gc = core->gc;

    // Stack allocated storage, so automatically these arrays are roots

    D* objs[1000];

    // Create strong references to 1000 objects

    for ( int i=0 ; i < 1000 ; i++ ) {
        objs[i] = new (gc) D();
    }

    // Get the collector into a reasonable state.

    gc->Collect();
    gc->Collect();

    // Remove the even-numbered strong refs.

    for ( int i=0 ; i < 1000 ; i+=2 )
        objs[i] = NULL;

    // Now trigger the collector again.

    gc->Collect();

// line 147 "ST_mmgc_weakref.st"
verifyPass(true, "true", __FILE__, __LINE__);
}

}
void create_mmgc_weakref(AvmCore* core) { new ST_mmgc_weakref(core); }
}
}
#endif

// Generated from ST_nanojit_codealloc.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_nanojit_codealloc {

// This conditionalization is clumsy, but we don't seem to have any other
// mechanism to enable a selftest conditionally upon the configuration.

#ifdef VMCFG_NANOJIT

using nanojit::NIns;
using nanojit::CodeList;
using nanojit::CodeAlloc;

static bool verbose = false;

class Randomizer {
private:

    TRandomFast seed;

public:

    Randomizer()
    {
        MathUtils::initRandom(&seed);
    }
    
    // Return integer in range [min,max).

    uint32_t range(uint32_t min, uint32_t max)
    {
        return min + MathUtils::Random(max - min, &seed);
    }
};

class CodeAllocDriver {
public:

    struct CodeListProfile {
        uint32_t largefreq;     // 1 in 'largefreq' chance codelist will be "large"
        uint32_t smallmin;      // Minimum size of "small" codelist
        uint32_t smallmax;      // Maximum size of "small" codelist
        uint32_t largemin;      // Minimum size of "large" codelist
        uint32_t largemax;      // Maximum size of "large" coelist
    };

    struct AllocationProfile {
        uint32_t limit;         // Largest block allocation permitted, zero for no limit
        uint32_t leftfreq;      // 1 in 'leftfreq' chance returned space will start at beginning of block
    };

    CodeAllocDriver(uint32_t max_codelists, CodeListProfile& codelist_profile, AllocationProfile& alloc_profile);
    
    void run(uint32_t iterations);
        
private:

    Randomizer rand;
    uint32_t n_active;          // Maximum number of simultaneously-allocated codelists
    CodeListProfile cp;         // Parameters controlling distribution of codelist sizes
    AllocationProfile ap;       // Parameters controlling allocation of each codelist

    void makeCodeList(uint32_t index, CodeAlloc& alloc, CodeList*& code);
};

CodeAllocDriver::CodeAllocDriver(uint32_t max_codelists, CodeListProfile& codelist_profile, AllocationProfile& alloc_profile)
    : n_active(max_codelists), cp(codelist_profile), ap(alloc_profile)
{}

// Create a codelist at the specified index in the codelist pool.
// The length of the codelist is generated pseudo-randomly.

void CodeAllocDriver::makeCodeList(uint32_t index, CodeAlloc& alloc, CodeList*& code)
{
     NIns* start;
     NIns* end;
  
     int32_t size = ((rand.range(0, cp.largefreq) > 0)
                     ? rand.range(cp.smallmin, cp.smallmax)
                     : rand.range(cp.largemin, cp.largemax));
     if (verbose)
         AvmLog("code-heap-test: codelist %d size %d\n", index, size);
     while (size > 0) {
         alloc.alloc(start, end, ap.limit);
         uint32_t blksize = uint32_t(end - start);
         if (verbose)
             AvmLog("code-heap-test: alloc  %x-%x %d\n", start, start, blksize);
         size -= blksize;
         if (size < 0) {
             // Last allocated block was not completely used, so we will return some of it.
             // We choose randomly whether to return a prefix of the block, or a segment out
             // of the middle.  This doesn't correspond precisely to normal usage in nanojit.
             // Note that if we are not retaining at least two bytes, we cannot split in the middle.
             int32_t excess = -size;
             if (rand.range(0, ap.leftfreq) > 0 || blksize - excess < 2) {
                 // Hole starts at left
                 // Note that hole at right is deliberately not handled in CodegenAlloc.cpp, results in assert.
                 if (verbose)
                     AvmLog("code-heap-test: hole l %x-%x %d\n", start, start + excess, excess);
                 alloc.addRemainder(code, start, end, start, start + excess);
             } else {
                 // Hole will go in middle
                 uint32_t offset = rand.range(1, blksize - excess);
                 if (verbose)
                     AvmLog("code-heap-test: hole m %x-%x %d\n", start + offset, start + offset + excess, excess);
                 alloc.addRemainder(code, start, end, start + offset, start + offset + excess);
             }
         } else {
             // Add entire block to codelist.
             CodeAlloc::add(code, start, end);
         }
     }
}

// Repeatedly construct and destroy codelists.
// We maintain a pool of codelists.  On each iteration, we replace one
// of the existing codelists with a new one, freeing the old.

void CodeAllocDriver::run(uint32_t iterations)
{
    nanojit::Config config;
    // Enable page protection flag checking during test code
    config.check_page_flags = true;

    CodeAlloc alloc(&config);

    CodeList** codelists = mmfx_new_array(CodeList*, n_active);

    VMPI_memset(codelists, 0, n_active * sizeof(CodeList*));

    for (uint32_t i = 0; i < iterations; i++) {
        uint32_t victim = rand.range(0, n_active);
        alloc.freeAll(codelists[victim]);
        makeCodeList(victim, alloc, codelists[victim]);
        //alloc.logStats();
        debug_only( alloc.sanity_check(); )
    }

    mmfx_delete_array(codelists);
}

#endif /* VMCFG_NANOJIT */

class ST_nanojit_codealloc : public Selftest {
public:
ST_nanojit_codealloc(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
};
ST_nanojit_codealloc::ST_nanojit_codealloc(AvmCore* core)
    : Selftest(core, "nanojit", "codealloc", ST_nanojit_codealloc::ST_names,ST_nanojit_codealloc::ST_explicits)
{}
const char* ST_nanojit_codealloc::ST_names[] = {"allocfree", NULL };
const bool ST_nanojit_codealloc::ST_explicits[] = {false, false };
void ST_nanojit_codealloc::run(int n) {
switch(n) {
case 0: test0(); return;
}
}

#ifdef VMCFG_NANOJIT

typedef CodeAllocDriver::CodeListProfile CodeListProfile;
typedef CodeAllocDriver::AllocationProfile AllocationProfile;

static CodeListProfile cp = { 5, 1, 1*1024, 1, 16*1024 };

static AllocationProfile ap[] = { { 0,     2 },
                                  #ifndef NANOJIT_64BIT
                                  // 128-byte minimum is too small on 64-bit platorms.
                                  { 128,   2 },
                                  #endif
                                  { 512,   2 },
                                  { 1024,  2 },
                                  { 2048,  2 },
                                  { 4096,  2 } };

static uint32_t n_ap = sizeof(ap) / sizeof(AllocationProfile);

#endif /* VMCFG_NANOJIT */

void ST_nanojit_codealloc::test0() {

#ifdef VMCFG_NANOJIT

for (uint32_t i = 0; i < n_ap; i++) {
    CodeAllocDriver* driver = mmfx_new(CodeAllocDriver(20, cp, ap[i]));
#if defined(DEBUG) && !(defined(VMCFG_IA32) || defined(VMCFG_AMD64))
    // This test is very slow in debug builds, due to the calls to sanity_check().
    // Run an abbreviated version of the test except on desktop platforms.
    driver->run(200);
#else
    driver->run(20000);
#endif
    mmfx_delete(driver);
 }

#endif /* VMCFG_NANOJIT */

// We pass if we don't crash or assert.
// line 194 "ST_nanojit_codealloc.st"
verifyPass(true, "true", __FILE__, __LINE__);


}
void create_nanojit_codealloc(AvmCore* core) { new ST_nanojit_codealloc(core); }
}
}
#endif

// Generated from ST_vmbase_concurrency.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_vmbase_concurrency {
using namespace MMgc;
using namespace vmbase;

// We use the same testing method as that for ST_vmpi_threads:
// Each construct is tested by (1) using it in the implementation of a mutator that
// modifies a counter for a fixed number of iterations, and then (2) running
// duplicates of that mutator in parallel. The final counter value ends up in
// sharedCounter, which is guarded by m_monitor (except for in CASTest).
// Each test checks that the sharedCounter ends up with a statically determined
// end value.
// (Description courtesy of Felix)

// We need a specific namespace as ST_vmpi_threads uses the same test class names
namespace selftestconcurrency {

    class ThreadTestBase : public Runnable {
        public:
            ThreadTestBase(int iterations) : m_iterations(iterations), sharedCounter(0) {
            }
            virtual ~ThreadTestBase() {
            }

        protected:
            WaitNotifyMonitor m_monitor;
            const int m_iterations;

        public:
            int sharedCounter;
    };

    class TestRunner {
        public:
            struct ThreadRecord {
                VMThread* thread;
                bool startupOk;
            };

            TestRunner(int threadQty, bool doJoin = true) : m_threadQty(threadQty), m_doJoin(doJoin) {
            }
            virtual ~TestRunner() {
            }

            void runTest(ThreadTestBase& test) {

                m_threads = mmfx_new_array(ThreadRecord, m_threadQty);

                // Start up the threads
                for (int i = 0; i < m_threadQty; i++) {
                    m_threads[i].thread = mmfx_new(VMThread(&test));
                    m_threads[i].startupOk = m_threads[i].thread->start();
                }

                // ...then block until they all terminate
                for (int i = 0; i < m_threadQty; i++) {
                    if (m_doJoin && m_threads[i].startupOk) {
                        m_threads[i].thread->join();
                    }
                    mmfx_delete(m_threads[i].thread);
                }

                mmfx_delete_array(m_threads);
            }

        private:
            const int m_threadQty;
            ThreadRecord* m_threads;
            bool m_doJoin;
    };

    class MutexTest : public ThreadTestBase {
        public:
            MutexTest(int iterations) : ThreadTestBase(iterations) {}
            virtual ~MutexTest() {}

            virtual void run() {
                AvmAssert(m_iterations % 2 == 0);
                for (int i = 0; i < m_iterations/2; i++) {
                    SCOPE_LOCK(m_monitor) {
                        SCOPE_LOCK(m_monitor) {
                            sharedCounter++;
                        }
                    }
                }
                for (int i = 0; i < m_iterations/2; i++) {
                    SCOPE_LOCK_NAMED(locker, m_monitor) {
                        SCOPE_LOCK_NAMED(locker, m_monitor) {
                            sharedCounter++;
                        }
                    }
                }
            }
    };
    class ConditionTest : public ThreadTestBase {
        public:
            ConditionTest(int iterations, int threadQty) : ThreadTestBase(iterations), m_threadQty(threadQty) {}
            virtual ~ConditionTest() {}

            virtual void run() {

                AvmAssert(m_threadQty >= 2);

                for (int i = 0; i < m_iterations; i++) {
                    SCOPE_LOCK_NAMED(locker, m_monitor) {
                        sharedCounter++;
                        // If there's another thread still active then wait.
                        if (m_threadQty > 1) {
                            locker.notify();
                            locker.wait();
                        }
                        // This thread has finished, so let's wake everyone else up
                        if (i == m_iterations - 1) {
                            --m_threadQty;
                            locker.notifyAll();
                        }
                    }

                }

            }

        private:
            int m_threadQty;
    };

    class AtomicCounterTest : public ThreadTestBase {
        public:
            AtomicCounterTest(int iterations, int threadQty) : ThreadTestBase(iterations), m_threadQty(threadQty) {}
            virtual ~AtomicCounterTest() {}

            virtual void run() {

                AvmAssert(m_iterations % 4 == 0);

                for (int i = 0; i < m_iterations/4; i++) {
                    m_counter++;
                }
                for (int i = 0; i < m_iterations/4; i++) {
                    m_counter--;
                }
                for (int i = 0; i < m_iterations/4; i++) {
                    ++m_counter;
                }
                for (int i = 0; i < m_iterations/4; i++) {
                    --m_counter;
                }

                SCOPE_LOCK(m_monitor) {
                    if (--m_threadQty == 0) {
                        sharedCounter = m_counter;
                    }
                }
            }
        private:
            AtomicCounter32 m_counter;
            int m_threadQty;
    };

    class CASTest : public ThreadTestBase {
        public:
            CASTest(int iterations, bool withBarrier) : ThreadTestBase(iterations), m_withBarrier(withBarrier) {}
            virtual ~CASTest() {}

            virtual void run() {
                if (m_withBarrier) {
                    for (int i = 0; i < m_iterations; i++) {
                        int32_t current, next;
                        do {
                            current = sharedCounter;
                            next = current + 1;
                        } while (!AtomicOps::compareAndSwap32WithBarrier(current, next, &sharedCounter));
                    }
                } else {
                    for (int i = 0; i < m_iterations; i++) {
                        int32_t current, next;
                        do {
                            current = sharedCounter;
                            next = current + 1;
                        } while (!AtomicOps::compareAndSwap32(current, next, &sharedCounter));
                    }
                }
            }
        private:
            bool m_withBarrier;
    };

    /**
     * We protect a shared counter with a Dekker-style lock that has been made
     * sequentially consistent with memory barriers.
     *
     * The idea is that if the barriers are correct, then two threads can compete
     * to update the counter n times each, so that the final counter value is 2n. If
     * the final value is not 2n, then the barriers have failed to ensure sequential
     * consistency.
     *
     * FIXME: bug 609943
     * This seems way too complicated. We have to be confident in the algorithm
     * before considering the barrier implementations, and I'm not convinced as yet.
     * Is there something simpler?
     * Note that the barriers below are extremely conservative.
     *
     * This is test is not actually run. The verifyPass below just returns true.
     */
    class MemoryBarrierTest : public ThreadTestBase {
        public:
            MemoryBarrierTest(int iterations) : ThreadTestBase(iterations), m_thread0(0), m_thread1(0), m_turn(NULL) {}
            virtual ~MemoryBarrierTest() {}

            virtual void run() {

                volatile int* me;
                volatile int* other;
                volatile int* const counterp = &sharedCounter;

                SCOPE_LOCK(m_monitor) {
                    if (m_turn == NULL) {
                        me = &m_thread0;
                        other = &m_thread1;
                        m_turn = me;
                    } else {
                        me = &m_thread1;
                        other = &m_thread0;
                    }
                }

                for (int i = 0; i < m_iterations; i++) {
                    // Dekker lock
                    *me = 1;
                    MemoryBarrier::readWrite();
                    while (*other == 1) {
                        MemoryBarrier::readWrite();
                        if (m_turn == other) {
                            MemoryBarrier::readWrite();
                            *me = 0;
                            MemoryBarrier::readWrite();
                            while (m_turn == other) {
                                MemoryBarrier::readWrite();
                            }
                            MemoryBarrier::readWrite();
                            *me = 1;
                            MemoryBarrier::readWrite();
                        }
                    }
                    MemoryBarrier::readWrite();
                    (*counterp)++;
                    MemoryBarrier::readWrite();
                    m_turn = other;
                    MemoryBarrier::readWrite();
                    *me = 0;
                    MemoryBarrier::readWrite();
                }
            }
        private:
            volatile int m_thread0;
            volatile int m_thread1;
            volatile int* volatile m_turn;
    };

    class ConditionWithWaitTest : public ThreadTestBase {
        public:
            ConditionWithWaitTest(int iterations) : ThreadTestBase(iterations) {}
            virtual ~ConditionWithWaitTest() {}

            virtual void run() {
                for (int i = 0; i < m_iterations; i++) {
                    SCOPE_LOCK_NAMED(locker, m_monitor) {
                        sharedCounter++;
                        locker.wait(1);
                    }
                }
            }
    };

    class SleepTest : public ThreadTestBase {
        public:
            SleepTest(int iterations) : ThreadTestBase(iterations) {}
            virtual ~SleepTest() {}

            virtual void run() {
                for (int i = 0; i < m_iterations; i++) {
                    SCOPE_LOCK(m_monitor) {
                        sharedCounter++;
                    }
                    VMThread::sleep(1);
                }
            }
    };

    class VMThreadLocalTest : public ThreadTestBase {
        public:
            VMThreadLocalTest(int iterations) : ThreadTestBase(iterations) {}
            virtual ~VMThreadLocalTest() {}

            virtual void run() {
                for (int i = 0; i < m_iterations; i++) {
                    m_localCounter.set(m_localCounter.get() + 1);
                }
                SCOPE_LOCK(m_monitor) {
                    sharedCounter += (int)m_localCounter;
                }
            }
        private:
            VMThreadLocal<uintptr_t> m_localCounter;
    };
}

// This needs to be at least 2 for ConditionTest
#define THREAD_QTY 4
#define ITERATIONS 100000

using namespace selftestconcurrency;

class ST_vmbase_concurrency : public Selftest {
public:
ST_vmbase_concurrency(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
void test8();
void test9();
};
ST_vmbase_concurrency::ST_vmbase_concurrency(AvmCore* core)
    : Selftest(core, "vmbase", "concurrency", ST_vmbase_concurrency::ST_names,ST_vmbase_concurrency::ST_explicits)
{}
const char* ST_vmbase_concurrency::ST_names[] = {"mutexes","conditions","atomic_counter","compare_and_swap_without_barrier","compare_and_swap_with_barrier","memory_barrier","condition_with_wait","sleep","vmthreadlocal","join", NULL };
const bool ST_vmbase_concurrency::ST_explicits[] = {false,false,false,false,false,false,false,false,false,false, false };
void ST_vmbase_concurrency::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
case 5: test5(); return;
case 6: test6(); return;
case 7: test7(); return;
case 8: test8(); return;
case 9: test9(); return;
}
}
void ST_vmbase_concurrency::test0() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    MutexTest test(ITERATIONS);
    runner.runTest(test);
// line 328 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test1() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    ConditionTest test(ITERATIONS, THREAD_QTY);
    runner.runTest(test);
// line 336 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test2() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    AtomicCounterTest test(ITERATIONS, THREAD_QTY);
    runner.runTest(test);
// line 344 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == 0, "test.sharedCounter == 0", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test3() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    CASTest test(ITERATIONS, false);
    runner.runTest(test);
// line 352 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test4() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    CASTest test(ITERATIONS, true);
    runner.runTest(test);
// line 360 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test5() {
#ifndef UNDER_CE
    /* This test is failing on Windows and Mac OSX 10.4.
     * For Windows, see bug 609820.
     * For Mac, are the 10.4 APIs not reliable?
     * It could also be the test, or the compiler!
     * FIXME: bug 609943 Selftests to stress memory barriers (fences)

    // Note that the memory barrier test is based on a Dekker lock, so we
    // only ever use 2 threads.
    TestRunner runner(2);
    MemoryBarrierTest test(ITERATIONS);
    runner.runTest(test);
// line 376 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == 2 * ITERATIONS, "test.sharedCounter == 2 * ITERATIONS", __FILE__, __LINE__);
    */
    
// line 379 "ST_vmbase_concurrency.st"
verifyPass(true, "true", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test6() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    ConditionWithWaitTest test(2000); // Use 2000 iterations with a 1 ms wait
    runner.runTest(test);
// line 387 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * 2000, "test.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test7() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    SleepTest test(2000); // Use 2000 iterations with a 1 ms sleep
    runner.runTest(test);
// line 395 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * 2000, "test.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test8() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY);
    VMThreadLocalTest test(ITERATIONS);
    runner.runTest(test);
// line 403 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_concurrency::test9() {
#ifndef UNDER_CE
    // We should be able to run the dtor of a non-started VMThread.
    {
        VMThread vmthread;
    }
    // Run the mutex test but call the VMThread dtors without joining first
    TestRunner runner(THREAD_QTY, false);
    MutexTest test(ITERATIONS);
    runner.runTest(test);
// line 416 "ST_vmbase_concurrency.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif





}
void create_vmbase_concurrency(AvmCore* core) { new ST_vmbase_concurrency(core); }
}
}
#endif

// Generated from ST_vmbase_safepoints.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if defined VMCFG_SAFEPOINTS && defined BUG_754918
namespace avmplus {
namespace ST_vmbase_safepoints {
using namespace MMgc;
using namespace vmbase;

    /**
     * Base class for tests run by a TestRunner.
     * Sub-classes should override runInSafepointManagerContext().
     */
    class SafepointTestBase : public Runnable
    {
    public:
        SafepointTestBase(SafepointManager& safepointManager, int iterations, int threadQty)
            : m_safepointManager(safepointManager)
            , m_iterations(iterations)
            , m_threadQty(threadQty)
            , sharedCounter(0)
        {
        }

        virtual ~SafepointTestBase()
        {
        }

        virtual void run()
        {
            // Enter the safepoint context shared by the primordial and worker threads
            SafepointRecord spRecord;
            m_safepointManager.enter(&spRecord);

            runInSafepointManagerContext();

            // Cleanup
            m_safepointManager.leave(&spRecord);
        }

        // Tests should override this function
        virtual void runInSafepointManagerContext() = 0;

        int threadQty()
        {
            return m_threadQty;
        }

    protected:
        SafepointManager& m_safepointManager;
        WaitNotifyMonitor m_monitor;
        const int m_iterations;
        const int m_threadQty;

    public:
        int sharedCounter;
    };

    /**
     * Creates the given number of VMThreads, and passes each the SafepointTestBase to execute.
     * The TestRunner contains the SafepointManager with which the primordial and each worker
     * thread will register their topmost SafepointRecord.
     */
    class TestRunner
    {
    public:
        struct ThreadRecord
        {
            VMThread* thread;
            bool startupOk;
        };

        TestRunner(bool doJoin = true)
            : m_doJoin(doJoin)
        {
        }

        virtual ~TestRunner()
        {
        }

        void runTest(SafepointTestBase& test)
        {
            // Enter the safepoint context shared by the primordial and worker threads
            SafepointRecord spRecord;
            m_safepointManager.enter(&spRecord);

            m_threads = mmfx_new_array(ThreadRecord, test.threadQty());

            // Start up the threads.
            // Each should also enter m_safepointManager
            for (int i = 0; i < test.threadQty(); i++) {
                m_threads[i].thread = mmfx_new(VMThread(&test));
                m_threads[i].startupOk = m_threads[i].thread->start();
            }

            // ...then block until they all terminate.
            // Whilst performing the join, this thread will
            // be implicitly safepointed.
            for (int i = 0; i < test.threadQty(); i++) {
                if (m_doJoin && m_threads[i].startupOk) {
                    m_threads[i].thread->join();
                }
                mmfx_delete(m_threads[i].thread);
            }

            mmfx_delete_array(m_threads);

            // Cleanup
            m_safepointManager.leave(&spRecord);
        }

        SafepointManager& safepointManager()
        {
            return m_safepointManager;
        }

    private:
        ThreadRecord* m_threads;
        bool m_doJoin;
        SafepointManager m_safepointManager;
    };

    /**
     * Threads increment a shared counter.
     * Thread safety is guaranteed by only performing the increment within a safepoint task.
     */
    class SimpleTest : public SafepointTestBase
    {
        class SimpleSafepointTask : public SafepointTask
        {
        public:
            SimpleSafepointTask(int& counter)
                : m_counter(counter)
            {
            }

            void run()
            {
                // We're in the safepoint task, so update
                // the shared counter;
                m_counter++;
            }

        private:
            int& m_counter;
        };

    public:
        SimpleTest(SafepointManager& safepointManager, int iterations, int threadQty)
            : SafepointTestBase(safepointManager, iterations, threadQty)
        {
        }

        virtual ~SimpleTest()
        {
        }

        // Thread entrypoint
        virtual void runInSafepointManagerContext()
        {
            for (int i = 0; i < m_iterations; i++) {
                // Increment shared counter in a safepoint task
                SimpleSafepointTask task(sharedCounter);
                m_safepointManager.requestSafepointTask(task);
            }
        }
    };

    /**
     * Producer-consumer with safepoints.
     *
     * Producer threads each increment a *private* counter in a tight
     * loop which includes a safepoint.
     *
     * A single consumer thread executes a tight loop which continually
     * requests that the producers be safepointed. In the safepoint task
     * the consumer 'steals' and then zeros the private counter of the
     * producers. Each stolen counter value is added to the consumer's
     * private counter.
     *
     * This continues until the producers have executed a fixed number of
     * iterations. At the end of this process the consumer should have
     * a deterministic private counter value.
     *
     */
    class ProducerConsumerTest : public SafepointTestBase
    {
    public:

        class ConsumerSafepointTask : public SafepointTask
        {
        public:
            ConsumerSafepointTask(int* producerCounters, int numProducers)
                : m_producerCounters(producerCounters)
                , m_numProducers(numProducers)
                , m_producerStolenCounter(0)
            {
            }

            void run()
            {
                // We're in the safepoint task, so we can steal and then zero
                // the producers' counters.
                // Note that we don't know how many producer threads are still
                // alive, m_numProducers is just the length of the array
                // we inspect.
                for (int i = 0; i < m_numProducers; i++) {
                    m_producerStolenCounter += m_producerCounters[i];
                    m_producerCounters[i] = 0;
                }
            }

            int producerStolenCounter()
            {
                return m_producerStolenCounter;
            }

        private:
            int* const m_producerCounters;
            const int m_numProducers;
            int m_producerStolenCounter;
        };

    public:
        ProducerConsumerTest(SafepointManager& safepointManager, int iterations, int threadQty)
            : SafepointTestBase(safepointManager, iterations, threadQty)
            , m_producerCounts(mmfx_new_array_opt(int, threadQty - 1, kZero))
        {
        }

        virtual ~ProducerConsumerTest()
        {
        }

        // Thread entrypoint
        virtual void runInSafepointManagerContext()
        {
            // Wait for all the threads to startup to force as much
            // contention as possible.
            const int threadIndex = m_threadIn++;
            SCOPE_LOCK_SP_NAMED(locker, m_monitor) {
                locker.notifyAll();
                while (m_threadIn < m_threadQty) {
                    locker.wait();
                }
            }

            // Setup one of the threads as the consumer, the others are producers
            if (threadIndex == m_threadQty - 1) {
                // The consumer continually makes SafepointTask requests on
                // the SafepointManager, leading to safepointed producers.
                // In each SafepointTask the consumer takes each producer's
                // currently accrued, private counter, and adds it
                // to its own total count, then zeroes the producers counter.
                int consumerCount = 0;
                enum State
                {
                    RUNNING, DRAINING, DONE
                };
                State state = RUNNING;
                do {
                    ConsumerSafepointTask task(m_producerCounts, m_threadQty - 1);
                    m_safepointManager.requestSafepointTask(task);
                    consumerCount += task.producerStolenCounter();
                    if (state == DRAINING) {
                        state = DONE;
                    } else if (m_threadOut == m_threadQty - 1) {
                        state = DRAINING;
                    }
                } while (state != DONE);

                // sharedCounter is verified by the selftest runner
                sharedCounter = consumerCount + m_iterations;

                // Can't do this in the dtor, if the selftest verify fails, it will
                // throw an exception and the dtor will not run.
                mmfx_delete_array(m_producerCounts);
            } else {
                // The producers increment their private counter, but we make sure that they
                // reach an explicit safepoint every iteration.
                for (int i = 0; i < m_iterations; i++) {
                    SAFEPOINT_POLL_FAST(m_safepointManager);
                    m_producerCounts[threadIndex]++;
                    if (i % 100 == 0)
                        VMPI_threadYield(); // Try to allow some interesting interleavings
                }
            }
            m_threadOut++;
        }
    private:
        int* m_producerCounts;
        AtomicCounter32 m_threadIn;
        AtomicCounter32 m_threadOut;
    };

    /**
     * Producer-consumer with nested/recursive (arbitrary depth) SafepointManagers.
     *
     * This test uses the same idea as ProducerConsumerTest, but instead of
     * having only one SafepointManager which is entered by all the producer
     * threads, there are N SafepointManagers which the producers continually
     * nest in and out of. Each producer maintains a private counter for each
     * SafepointManager nesting level, which it only increments when in the
     * context of the corresponding SafepointManager.
     *
     * Similar to the producers, the consumer continually nests in and out of
     * the stack of SafepointManagers. At each nesting level the consumer
     * requests that the producers be safepointed with respect to the
     * SafepointManager at that nesting level. In the safepoint task
     * the consumer 'steals' and then zeros the private counter of the
     * producers for that level. Each stolen counter value is added to
     * the consumer's private counter.
     *
     * This continues until the producers have executed a fixed number of
     * iterations for each nesting level. At the end of this process the
     * consumer should have a deterministic private counter value.
     *
     * Note, to test both recursive and nested SafepointManager entry,
     * the SafepointManager used for the final nesting level is the
     * same as the first.
     */
    class NestedProducerConsumerTest : public SafepointTestBase
    {

    public:
        NestedProducerConsumerTest(SafepointManager& safepointManager, int iterations, int threadQty, int nestingDepth)
            : SafepointTestBase(safepointManager, iterations, threadQty)
            , m_nestingDepth(nestingDepth)
        {
            m_nestedManagers = mmfx_new_array(SafepointManager, m_nestingDepth);
            m_producerCounters = mmfx_new_array(int*, m_nestingDepth + 1);
            for (int i = 0; i < m_nestingDepth + 1; i++) {
                m_producerCounters[i] = mmfx_new_array_opt(int, threadQty - 1, kZero);
            }
        }

        virtual ~NestedProducerConsumerTest()
        {
        }

        int nestedConsume(int depth)
        {
            if (depth == -1) {
                // Fish for asserts:
                // At the deepest nesting level recurse into the oldest SafepointManager on the stack.
                SafepointRecord record;
                m_safepointManager.enter(&record);
                ProducerConsumerTest::ConsumerSafepointTask task(m_producerCounters[0], m_threadQty - 1);
                m_safepointManager.requestSafepointTask(task);
                m_safepointManager.leave(&record);
                return task.producerStolenCounter();;
            }
            SafepointRecord record;
            m_nestedManagers[depth].enter(&record);
            ProducerConsumerTest::ConsumerSafepointTask task(m_producerCounters[depth + 1], m_threadQty - 1);
            m_nestedManagers[depth].requestSafepointTask(task);
            int consumerCount = task.producerStolenCounter();

            // Next SafepointManager
            consumerCount += nestedConsume(depth - 1);

            m_nestedManagers[depth].leave(&record);
            return consumerCount;
        }

        void nestedProduce(int depth, int iterations, int threadIndex)
        {
            if (depth == -1) {
                // Fish for asserts:
                // At the deepest nesting level recurse into the oldest SafepointManager on the stack.
                SafepointRecord record;
                m_safepointManager.enter(&record);
                for (int i = 0; i < iterations; i++) {
                    SAFEPOINT_POLL_FAST(m_safepointManager);
                    m_producerCounters[0][threadIndex]++;
                }
                m_safepointManager.leave(&record);
                return;
            }
            SafepointRecord record;
            m_nestedManagers[depth].enter(&record);
            for (int i = 0; i < iterations; i++) {
                SAFEPOINT_POLL_FAST(m_nestedManagers[depth]);
                m_producerCounters[depth + 1][threadIndex]++;
            }
            VMPI_threadYield(); // Try to allow some interesting interleavings

            // Next SafepointManager
            nestedProduce(depth - 1, iterations, threadIndex);

            m_nestedManagers[depth].leave(&record);
        }

        // Thread entrypoint
        virtual void runInSafepointManagerContext()
        {
            // Wait for all the threads to startup to force as much
            // contention as possible.
            const int threadIndex = m_threadIn++;
            SCOPE_LOCK_SP_NAMED(locker, m_monitor) {
                locker.notifyAll();
                while (m_threadIn < m_threadQty) {
                    locker.wait();
                }
            }

            // Setup one of the threads as the consumer, the others are producers
            if (threadIndex == m_threadQty - 1) {
                // The consumer continually makes SafepointTask requests on
                // the SafepointManager at each nesting level, leading to
                // safepointed producers. In each SafepointTask the consumer
                // takes each producer's currently accrued, private counter at
                // the current nesting depth, and adds it to its own total count,
                // then zeroes the producers counter.
                int consumerCount = 0;
                enum State
                {
                    RUNNING, DRAINING, DONE
                };
                State state = RUNNING;
                do {
                    ProducerConsumerTest::ConsumerSafepointTask task(m_producerCounters[0], m_threadQty - 1);
                    m_safepointManager.requestSafepointTask(task);
                    consumerCount += task.producerStolenCounter();
                    consumerCount += nestedConsume(m_nestingDepth - 1);
                    if (state == DRAINING) {
                        state = DONE;
                    } else if (m_threadOut == m_threadQty - 1) {
                        state = DRAINING;
                    }
                } while (state != DONE);

                // sharedCounter is verified by the selftest runner
                sharedCounter = consumerCount + m_iterations;

                // Can't do this in the dtor, if the selftest verify fails, it will
                // throw an exception and the dtor will not run.
                for (int i = 0; i < m_nestingDepth + 1; i++) {
                    mmfx_delete_array(m_producerCounters[i]);
                }
                mmfx_delete_array(m_producerCounters);
                mmfx_delete_array(m_nestedManagers);
            } else {
                // How many increments should we perform each time we visit
                // a nesting depth?
                const int incPerDepth = m_iterations / 1000;
                const int iterations = m_iterations / (incPerDepth * (m_nestingDepth + 2));
                // The producers increment their private counter at each nesting depth,
                // but we make sure that they reach an explicit safepoint every iteration.
                for (int i = 0; i < iterations; i++) {
                    for (int j = 0; j < incPerDepth; j++) {
                        SAFEPOINT_POLL_FAST(m_safepointManager);
                        m_producerCounters[0][threadIndex]++;
                    }
                    nestedProduce(m_nestingDepth - 1, incPerDepth, threadIndex);
                    VMPI_threadYield(); // Try to allow some interesting interleavings
                }
                const int balance = m_iterations % (incPerDepth * (m_nestingDepth + 2));
                for (int i = 0; i < balance; i++) {
                    SAFEPOINT_POLL_FAST(m_safepointManager);
                    m_producerCounters[0][threadIndex]++;
                }
            }
            m_threadOut++;
        }
    private:
        int** m_producerCounters;
        const int m_nestingDepth;
        SafepointManager* m_nestedManagers;
        AtomicCounter32 m_threadIn;
        AtomicCounter32 m_threadOut;
    };

// Must be >=2 for ProducerConsumerTest and NestedProducerConsumerTest
#define THREAD_QTY 4

// Must be >= 1000 for NestedProducerConsumerTest
#define ITERATIONS 100000

// For NestedProducerConsumerTest
#define NESTING_DEPTH 7

class ST_vmbase_safepoints : public Selftest {
public:
ST_vmbase_safepoints(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
};
ST_vmbase_safepoints::ST_vmbase_safepoints(AvmCore* core)
    : Selftest(core, "vmbase", "safepoints", ST_vmbase_safepoints::ST_names,ST_vmbase_safepoints::ST_explicits)
{}
const char* ST_vmbase_safepoints::ST_names[] = {"simple","producer_consumer","nested_producer_consumer", NULL };
const bool ST_vmbase_safepoints::ST_explicits[] = {false,false,false, false };
void ST_vmbase_safepoints::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
}
}
void ST_vmbase_safepoints::test0() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY!=0);
    SimpleTest test(runner.safepointManager(), ITERATIONS, THREAD_QTY);
    runner.runTest(test);
// line 496 "ST_vmbase_safepoints.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_safepoints::test1() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY!=0);
    ProducerConsumerTest test(runner.safepointManager(), ITERATIONS, THREAD_QTY);
    runner.runTest(test);
// line 504 "ST_vmbase_safepoints.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS, "test.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmbase_safepoints::test2() {
#ifndef UNDER_CE
    TestRunner runner(THREAD_QTY!=0);
    NestedProducerConsumerTest test(runner.safepointManager(), ITERATIONS * 100, THREAD_QTY, NESTING_DEPTH);
    runner.runTest(test);
// line 512 "ST_vmbase_safepoints.st"
verifyPass(test.sharedCounter == THREAD_QTY * ITERATIONS * 100, "test.sharedCounter == THREAD_QTY * ITERATIONS * 100", __FILE__, __LINE__);
#endif




}
void create_vmbase_safepoints(AvmCore* core) { new ST_vmbase_safepoints(core); }
}
}
#endif
#endif

// Generated from ST_vmpi_threads.st
// -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
//
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

// Bugzilla 543560 - here we risk deleting an object that is still on the mark stack because
// of how we perform large-object splitting.  The setup is that user code that deletes the object
// gets to run after the first part of the large object has been popped off the mark stack
// but before the rest has been handled.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_vmpi_threads {
using namespace MMgc;

    class ThreadTestBase {
        public:
            struct ThreadRecord {
                vmpi_thread_t thread;
                int id;
                bool startupOk;
            };

            ThreadTestBase(int threadQty, int iterations) : m_threadQty(threadQty), m_iterations(iterations), sharedCounter(0) {
                VMPI_recursiveMutexInit(&m_mutex);
                VMPI_condVarInit(&m_condition);
            }
            virtual ~ThreadTestBase() {
                VMPI_recursiveMutexDestroy(&m_mutex);
                VMPI_condVarDestroy(&m_condition);
            }

            void runTest() {

                ThreadRecord* threads = mmfx_new_array(ThreadRecord, m_threadQty);

                // Start up the threads
                for (int i = 0; i < m_threadQty; i++) {
                    threads[i].id = i;
                    threads[i].startupOk = VMPI_threadCreate(&threads[i].thread, NULL, _workerThreadEntry, this);
                }

                // ...then block until they all terminate
                for (int i = 0; i < m_threadQty; i++) {
                    if (threads[i].startupOk) {
                        VMPI_threadJoin(threads[i].thread);
                    }
                }

                mmfx_delete_array(threads);
            }
            
            static vmpi_thread_rtn_t VMPI_THREAD_START_CC detachbleThreadEntry(vmpi_thread_arg_t) {
                VMPI_threadDetach(VMPI_currentThread());
                return NULL;
            }
            
            static vmpi_thread_rtn_t VMPI_THREAD_START_CC joinableThreadEntry(vmpi_thread_arg_t) {
                return NULL;
            }

        protected:
            virtual void workerThreadEntry() {}

        private:
            static vmpi_thread_rtn_t VMPI_THREAD_START_CC _workerThreadEntry(vmpi_thread_arg_t arg) {
                ((ThreadTestBase*)arg)->workerThreadEntry();
                return NULL;
            }

        protected:
            const int m_threadQty;
            vmpi_mutex_t m_mutex;
            vmpi_condvar_t m_condition;
            const int m_iterations;
            
        public:
            int sharedCounter;
    };
    
    class MutexTest : public ThreadTestBase {
        public:
            MutexTest(int threadQty, int iterations) : ThreadTestBase(threadQty, iterations) {}
            virtual ~MutexTest() {}

            virtual void workerThreadEntry() {
                for (int i = 0; i < m_iterations; i++) {
                    VMPI_recursiveMutexLock(&m_mutex);
                    VMPI_recursiveMutexLock(&m_mutex);
                    sharedCounter++;
                    VMPI_recursiveMutexUnlock(&m_mutex);
                    VMPI_recursiveMutexUnlock(&m_mutex);
                }
            }
    };
    
    
    class ConditionTest : public ThreadTestBase {
        public:
            ConditionTest(int threadQty, int iterations) : ThreadTestBase(threadQty, iterations), m_finishedQty(0) {}
            virtual ~ConditionTest() {}

            virtual void workerThreadEntry() {
                if (m_threadQty < 2) {
                    return;
                }

                for (int i = 0; i < m_iterations; i++) {
                    VMPI_recursiveMutexLock(&m_mutex);
                    sharedCounter++;
                    
                    // If there's another thread still active then wait.
                    if (m_finishedQty < m_threadQty - 1) {
                        VMPI_condVarSignal(&m_condition);
                        VMPI_condVarWait(&m_condition, &m_mutex);
                    }
                    
                    // This thread has finished, so let's wake everyone else up
                    if (i == m_iterations - 1) {
                        m_finishedQty++;
                        VMPI_condVarBroadcast(&m_condition);
                    }
                    VMPI_recursiveMutexUnlock(&m_mutex);

                }

            }

        private:
            int m_finishedQty;
    };

    class AtomicIncrementTest : public ThreadTestBase {
        public:
            AtomicIncrementTest(int threadQty, int iterations, bool withBarrier) : ThreadTestBase(threadQty, iterations), m_withBarrier(withBarrier) {}
            virtual ~AtomicIncrementTest() {}

            virtual void workerThreadEntry() {
                if (m_withBarrier) {
                    for (int i = 0; i < m_iterations; i++) {
                        VMPI_atomicIncAndGet32WithBarrier(&sharedCounter);
                    }
                } else {
                    for (int i = 0; i < m_iterations; i++) {
                        VMPI_atomicIncAndGet32(&sharedCounter);
                    }
                }
            }
        private:
            bool m_withBarrier;
    };

    class AtomicDecrementTest : public ThreadTestBase {
        public:
            AtomicDecrementTest(int threadQty, int iterations, bool withBarrier) : ThreadTestBase(threadQty, iterations), m_withBarrier(withBarrier) {}
            virtual ~AtomicDecrementTest() {}

            virtual void workerThreadEntry() {
                if (m_withBarrier) {
                    for (int i = 0; i < m_iterations; i++) {
                        VMPI_atomicDecAndGet32WithBarrier(&sharedCounter);
                    }
                } else {
                    for (int i = 0; i < m_iterations; i++) {
                        VMPI_atomicDecAndGet32(&sharedCounter);
                    }
                }
            }
        private:
            bool m_withBarrier;
    };

    class CASTest : public ThreadTestBase {
        public:
            CASTest(int threadQty, int iterations, bool withBarrier) : ThreadTestBase(threadQty, iterations), m_withBarrier(withBarrier) {}
            virtual ~CASTest() {}

            virtual void workerThreadEntry() {
                if (m_withBarrier) {
                    for (int i = 0; i < m_iterations; i++) {
                        int32_t current, next;
                        do {
                            current = sharedCounter;
                            next = current + 1;
                        } while (!VMPI_compareAndSwap32WithBarrier(current, next, &sharedCounter));
                    }
                } else {
                    for (int i = 0; i < m_iterations; i++) {
                        int32_t current, next;
                        do {
                            current = sharedCounter;
                            next = current + 1;
                        } while (!VMPI_compareAndSwap32(current, next, &sharedCounter));
                    }
                }
            }
        private:
            bool m_withBarrier;
    };

    /**
     * We protect a shared counter with a Dekker-style lock that has been made
     * sequentially consistent with memory barriers.
     *
     * The idea is that if the barriers are correct, then two threads can compete
     * to update the counter n times each, so that the final counter value is 2n. If
     * the final value is not 2n, then the barriers have failed to ensure sequential
     * consistency.
     *
     * FIXME: bug 609943
     * This seems way too complicated. We have to be confident in the algorithm
     * before considering the barrier implementations, and I'm not convinced as yet.
     * Is there something simpler?
     *
     * This is test is not actually run. The verifyPass below just returns true.
     */
    class MemoryBarrierTest : public ThreadTestBase {
        public:
            MemoryBarrierTest(int iterations) : ThreadTestBase(2, iterations), m_thread0(0), m_thread1(0), m_turn(NULL) {}
            virtual ~MemoryBarrierTest() {}

            virtual void workerThreadEntry() {

                volatile int* me;
                volatile int* other;
                volatile int* const counterp = &sharedCounter;

                VMPI_recursiveMutexLock(&m_mutex);
                if (m_turn == NULL) {
                    me = &m_thread0;
                    other = &m_thread1;
                    m_turn = me;
                } else {
                    me = &m_thread1;
                    other = &m_thread0;
                }
                VMPI_recursiveMutexUnlock(&m_mutex);

                for (int i = 0; i < m_iterations; i++) {
                    // Dekker lock
                    *me = 1;
                    VMPI_memoryBarrier();
                    while (*other == 1) {
                        VMPI_memoryBarrier();
                        if (m_turn == other) {
                            VMPI_memoryBarrier();
                            *me = 0;
                            VMPI_memoryBarrier();
                            while (m_turn == other) {
                                VMPI_memoryBarrier();
                            }
                            VMPI_memoryBarrier();
                            *me = 1;
                            VMPI_memoryBarrier();
                        }
                    }
                    VMPI_memoryBarrier();
                    (*counterp)++;
                    VMPI_memoryBarrier();
                    m_turn = other;
                    VMPI_memoryBarrier();
                    *me = 0;
                    VMPI_memoryBarrier();
                }
        }
        private:
            volatile int m_thread0;
            volatile int m_thread1;
            volatile int* volatile m_turn;
    };
    
    class TryLockTest : public ThreadTestBase {
        public:
            TryLockTest(int threadQty, int iterations) : ThreadTestBase(threadQty, iterations) {}
            virtual ~TryLockTest() {}

            virtual void workerThreadEntry() {
                for (int i = 0; i < m_iterations; i++) {
                    int counter = 0;
                    while (!VMPI_recursiveMutexTryLock(&m_mutex)) {
                        ++counter;
                        if((counter & 63) == 0) {
                            VMPI_threadSleep(1);
                        } 
                    }
                    sharedCounter++;
                    VMPI_recursiveMutexUnlock(&m_mutex);
                }
            }
    };
    
    class ConditionWithWaitTest : public ThreadTestBase {
        public:
            ConditionWithWaitTest(int threadQty, int iterations) : ThreadTestBase(threadQty, iterations) {}
            virtual ~ConditionWithWaitTest() {}

            virtual void workerThreadEntry() {
                for (int i = 0; i < m_iterations; i++) {
                    VMPI_recursiveMutexLock(&m_mutex);
                    sharedCounter++;
                    VMPI_condVarTimedWait(&m_condition, &m_mutex, 1);
                    VMPI_recursiveMutexUnlock(&m_mutex);
                }
            }
    };
    
    class SleepTest : public ThreadTestBase {
        public:
            SleepTest(int threadQty, int iterations) : ThreadTestBase(threadQty, iterations) {}
            virtual ~SleepTest() {}

            virtual void workerThreadEntry() {
                for (int i = 0; i < m_iterations; i++) {
                    VMPI_recursiveMutexLock(&m_mutex);
                    sharedCounter++;
                    VMPI_recursiveMutexUnlock(&m_mutex);
                    VMPI_threadSleep(1);
                }
            }
    };

// This needs to be at least 2 for ConditionTest
#define THREAD_QTY 4

#define ITERATIONS 100000

class ST_vmpi_threads : public Selftest {
public:
ST_vmpi_threads(AvmCore* core);
virtual void run(int n);
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
void test8();
void test9();
void test10();
void test11();
void test12();
void test13();
};
ST_vmpi_threads::ST_vmpi_threads(AvmCore* core)
    : Selftest(core, "vmpi", "threads", ST_vmpi_threads::ST_names,ST_vmpi_threads::ST_explicits)
{}
const char* ST_vmpi_threads::ST_names[] = {"mutexes","conditions","atomic_increment_without_barrier","atomic_decrement_without_barrier","compare_and_swap_without_barrier","atomic_increment_with_barrier","atomic_decrement_with_barrier","compare_and_swap_with_barrier","memory_barrier","try_lock","condition_with_wait","sleep","detach","thread_attributes", NULL };
const bool ST_vmpi_threads::ST_explicits[] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false, false };
void ST_vmpi_threads::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
case 5: test5(); return;
case 6: test6(); return;
case 7: test7(); return;
case 8: test8(); return;
case 9: test9(); return;
case 10: test10(); return;
case 11: test11(); return;
case 12: test12(); return;
case 13: test13(); return;
}
}
void ST_vmpi_threads::test0() {
#ifndef UNDER_CE
    MutexTest mutexTest(THREAD_QTY, ITERATIONS);
    mutexTest.runTest();
// line 334 "ST_vmpi_threads.st"
verifyPass(mutexTest.sharedCounter == THREAD_QTY * ITERATIONS, "mutexTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test1() {
#ifndef UNDER_CE
    ConditionTest conditionTest(THREAD_QTY, ITERATIONS);
    conditionTest.runTest();
// line 341 "ST_vmpi_threads.st"
verifyPass(conditionTest.sharedCounter == THREAD_QTY * ITERATIONS, "conditionTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test2() {
#ifndef UNDER_CE
    AtomicIncrementTest atomicIncrementTest(THREAD_QTY, ITERATIONS, false);
    atomicIncrementTest.runTest();
// line 348 "ST_vmpi_threads.st"
verifyPass(atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS, "atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif
    
}
void ST_vmpi_threads::test3() {
#ifndef UNDER_CE
    AtomicDecrementTest atomicDecrementTest(THREAD_QTY, ITERATIONS, false);
    atomicDecrementTest.runTest();
// line 355 "ST_vmpi_threads.st"
verifyPass(atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS), "atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS)", __FILE__, __LINE__);
#endif
    
}
void ST_vmpi_threads::test4() {
#ifndef UNDER_CE
    CASTest casTest(THREAD_QTY, ITERATIONS, false);
    casTest.runTest();
// line 362 "ST_vmpi_threads.st"
verifyPass(casTest.sharedCounter == THREAD_QTY * ITERATIONS, "casTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test5() {
#ifndef UNDER_CE
    AtomicIncrementTest atomicIncrementTest(THREAD_QTY, ITERATIONS, true);
    atomicIncrementTest.runTest();
// line 369 "ST_vmpi_threads.st"
verifyPass(atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS, "atomicIncrementTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif
    
}
void ST_vmpi_threads::test6() {
#ifndef UNDER_CE
    AtomicDecrementTest atomicDecrementTest(THREAD_QTY, ITERATIONS, true);
    atomicDecrementTest.runTest();
// line 376 "ST_vmpi_threads.st"
verifyPass(atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS), "atomicDecrementTest.sharedCounter == -(THREAD_QTY * ITERATIONS)", __FILE__, __LINE__);
#endif
    
}
void ST_vmpi_threads::test7() {
#ifndef UNDER_CE
    CASTest casTest(THREAD_QTY, ITERATIONS, true);
    casTest.runTest();
// line 383 "ST_vmpi_threads.st"
verifyPass(casTest.sharedCounter == THREAD_QTY * ITERATIONS, "casTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test8() {
#ifndef UNDER_CE
    /* This test is failing on Windows and Mac OSX 10.4.
     * For Windows, see bug 609820.
     * For Mac, are the 10.4 APIs not reliable?
     * It could also be the test, or the compiler!
     * FIXME: bug 609943 Selftests to stress memory barriers (fences)
    
    // Note that the memory barrier test is based on a Dekker lock, so we
    // only ever use 2 threads.
    MemoryBarrierTest memoryBarrierTest(ITERATIONS);
    memoryBarrierTest.runTest();
// line 398 "ST_vmpi_threads.st"
verifyPass(memoryBarrierTest.sharedCounter == 2 * ITERATIONS, "memoryBarrierTest.sharedCounter == 2 * ITERATIONS", __FILE__, __LINE__);
    
    */
// line 401 "ST_vmpi_threads.st"
verifyPass(true, "true", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test9() {
#ifndef UNDER_CE
    TryLockTest tryLockTest(THREAD_QTY, ITERATIONS);
    tryLockTest.runTest();
// line 408 "ST_vmpi_threads.st"
verifyPass(tryLockTest.sharedCounter == THREAD_QTY * ITERATIONS, "tryLockTest.sharedCounter == THREAD_QTY * ITERATIONS", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test10() {
#ifndef UNDER_CE
    // Use 2000 iterations with a 1 ms wait
    ConditionWithWaitTest conditionWithWaitTest(THREAD_QTY, 2000);
    conditionWithWaitTest.runTest();
// line 416 "ST_vmpi_threads.st"
verifyPass(conditionWithWaitTest.sharedCounter == THREAD_QTY * 2000, "conditionWithWaitTest.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test11() {
#ifndef UNDER_CE
    // Use 2000 iterations with a 1 ms sleep
    SleepTest sleepTest(THREAD_QTY, 2000);
    sleepTest.runTest();
// line 424 "ST_vmpi_threads.st"
verifyPass(sleepTest.sharedCounter == THREAD_QTY * 2000, "sleepTest.sharedCounter == THREAD_QTY * 2000", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test12() {
#ifndef UNDER_CE
    // We can't really test for much here...
    vmpi_thread_t thread;
    VMPI_threadCreate(&thread, NULL, ThreadTestBase::detachbleThreadEntry, NULL);
// line 432 "ST_vmpi_threads.st"
verifyPass(true, "true", __FILE__, __LINE__);
#endif

}
void ST_vmpi_threads::test13() {
#ifndef UNDER_CE
    vmpi_thread_attr_t attr;
// line 438 "ST_vmpi_threads.st"
verifyPass(VMPI_threadAttrInit(&attr) == true, "VMPI_threadAttrInit(&attr) == true", __FILE__, __LINE__);
    
    VMPI_threadAttrSetGuardSize(&attr, VMPI_threadAttrDefaultGuardSize());
    VMPI_threadAttrSetStackSize(&attr, VMPI_threadAttrDefaultStackSize());
    VMPI_threadAttrSetPriorityLow(&attr);
    VMPI_threadAttrSetPriorityNormal(&attr);
    VMPI_threadAttrSetPriorityHigh(&attr);
    
    vmpi_thread_t thread;
    bool started = VMPI_threadCreate(&thread, &attr, ThreadTestBase::joinableThreadEntry, NULL);
// line 448 "ST_vmpi_threads.st"
verifyPass(started == true, "started == true", __FILE__, __LINE__);
    if (started) {
        VMPI_threadJoin(thread);
    }
    
// line 453 "ST_vmpi_threads.st"
verifyPass(VMPI_threadAttrDestroy(&attr) == true, "VMPI_threadAttrDestroy(&attr) == true", __FILE__, __LINE__);
#endif


}
void create_vmpi_threads(AvmCore* core) { new ST_vmpi_threads(core); }
}
}
#endif

// Generated from ST_workers_Buffer.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if !defined DEBUGGER
namespace avmplus {
namespace ST_workers_Buffers {
class ST_workers_Buffers : public Selftest {
public:
ST_workers_Buffers(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
void test4();
void test5();
void test6();
void test7();
    MMgc::GC *gc;
    NoSyncSingleItemBuffer *singleItemBuffer;
    NoSyncMultiItemBuffer *multiItemBuffer;
    NonBlockingMultiItemBuffer *nonBlockMultiItemBuffer;
    Atom *atom;
 
};
ST_workers_Buffers::ST_workers_Buffers(AvmCore* core)
    : Selftest(core, "workers", "Buffers", ST_workers_Buffers::ST_names,ST_workers_Buffers::ST_explicits)
{}
const char* ST_workers_Buffers::ST_names[] = {"NonBlockMultiItemConstructor","NonBlockMultiItemEmptyBuffer","NonBlockMultiItemFullBuffer","SingleConstructor","SingleEmptyBuffer","SingleFullBuffer","MultiConstructor","MultiEmptyBuffer", NULL };
const bool ST_workers_Buffers::ST_explicits[] = {false,false,false,false,false,false,false,false, false };
void ST_workers_Buffers::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
case 4: test4(); return;
case 5: test5(); return;
case 6: test6(); return;
case 7: test7(); return;
}
}
void ST_workers_Buffers::prologue() {
    MMgc::GCConfig config;
    gc = new MMgc::GC(MMgc::GCHeap::GetGCHeap(), config);
	//gc=core->GetGC();
    atom=(Atom *)malloc(100);
    singleItemBuffer=new NoSyncSingleItemBuffer(gc);
    multiItemBuffer=new NoSyncMultiItemBuffer();
    nonBlockMultiItemBuffer=new NonBlockingMultiItemBuffer(gc);

}
void ST_workers_Buffers::epilogue() {
    delete singleItemBuffer;
    delete multiItemBuffer;
    delete nonBlockMultiItemBuffer;
	delete gc;
    free(atom);

}
void ST_workers_Buffers::test0() {
// line 37 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer!=NULL, "nonBlockMultiItemBuffer!=NULL", __FILE__, __LINE__);

}
void ST_workers_Buffers::test1() {
// line 40 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->isEmpty(), "nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 41 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
// line 42 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->get(atom), "!nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);

}
void ST_workers_Buffers::test2() {
    bool result;
    for (int i=0;i<14;i++) {
        result=nonBlockMultiItemBuffer->put(String::createLatin1(core,"test string")->atom());
// line 48 "ST_workers_Buffer.st"
verifyPass(result, "result", __FILE__, __LINE__);
// line 49 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 50 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
    }
    result=nonBlockMultiItemBuffer->put(String::createLatin1(core,"test string")->atom());
// line 53 "ST_workers_Buffer.st"
verifyPass(result, "result", __FILE__, __LINE__);
// line 54 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 55 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->isFull(), "nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);

    result=nonBlockMultiItemBuffer->put(String::createLatin1(core,"test string")->atom());
// line 58 "ST_workers_Buffer.st"
verifyPass(!result, "!result", __FILE__, __LINE__);
// line 59 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 60 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->isFull(), "nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);

    for (int i=0;i<14;i++) {
// line 63 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->get(atom), "nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
// line 64 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isEmpty(), "!nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 65 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);
    }
// line 67 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->get(atom), "nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
// line 68 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->isEmpty(), "nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 69 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);

// line 71 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->get(atom), "!nonBlockMultiItemBuffer->get(atom)", __FILE__, __LINE__);
// line 72 "ST_workers_Buffer.st"
verifyPass(nonBlockMultiItemBuffer->isEmpty(), "nonBlockMultiItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 73 "ST_workers_Buffer.st"
verifyPass(!nonBlockMultiItemBuffer->isFull(), "!nonBlockMultiItemBuffer->isFull()", __FILE__, __LINE__);

}
void ST_workers_Buffers::test3() {
// line 76 "ST_workers_Buffer.st"
verifyPass(singleItemBuffer!=NULL, "singleItemBuffer!=NULL", __FILE__, __LINE__);

}
void ST_workers_Buffers::test4() {
// line 79 "ST_workers_Buffer.st"
verifyPass(singleItemBuffer->isEmpty(), "singleItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 80 "ST_workers_Buffer.st"
verifyPass(!singleItemBuffer->isFull(), "!singleItemBuffer->isFull()", __FILE__, __LINE__);
// line 81 "ST_workers_Buffer.st"
verifyPass(!singleItemBuffer->get(atom), "!singleItemBuffer->get(atom)", __FILE__, __LINE__);

}
void ST_workers_Buffers::test5() {
    bool result;
    result=singleItemBuffer->put(String::createLatin1(core,"test string")->atom());
// line 86 "ST_workers_Buffer.st"
verifyPass(result, "result", __FILE__, __LINE__);
// line 87 "ST_workers_Buffer.st"
verifyPass(!singleItemBuffer->isEmpty(), "!singleItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 88 "ST_workers_Buffer.st"
verifyPass(singleItemBuffer->isFull(), "singleItemBuffer->isFull()", __FILE__, __LINE__);
    result=singleItemBuffer->put(String::createLatin1(core,"test string")->atom());
// line 90 "ST_workers_Buffer.st"
verifyPass(!result, "!result", __FILE__, __LINE__);
// line 91 "ST_workers_Buffer.st"
verifyPass(singleItemBuffer->get(atom), "singleItemBuffer->get(atom)", __FILE__, __LINE__);
// line 92 "ST_workers_Buffer.st"
verifyPass(singleItemBuffer->isEmpty(), "singleItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 93 "ST_workers_Buffer.st"
verifyPass(!singleItemBuffer->isFull(), "!singleItemBuffer->isFull()", __FILE__, __LINE__);

}
void ST_workers_Buffers::test6() {
// line 96 "ST_workers_Buffer.st"
verifyPass(multiItemBuffer!=NULL, "multiItemBuffer!=NULL", __FILE__, __LINE__);

}
void ST_workers_Buffers::test7() {
// line 99 "ST_workers_Buffer.st"
verifyPass(singleItemBuffer->isEmpty(), "singleItemBuffer->isEmpty()", __FILE__, __LINE__);
// line 100 "ST_workers_Buffer.st"
verifyPass(!singleItemBuffer->isFull(), "!singleItemBuffer->isFull()", __FILE__, __LINE__);
// line 101 "ST_workers_Buffer.st"
verifyPass(!singleItemBuffer->get(atom), "!singleItemBuffer->get(atom)", __FILE__, __LINE__);

// Bugzilla: https://bugzilla.mozilla.org/show_bug.cgi?id=758260
//%%test MultiFullBuffer
//    bool result;
//    for (int i=0;i<15;i++) {
//        ChannelItem item;
//        item.tag = kDoubleType;
//        item.asNumber = 3.14;
//        result=multiItemBuffer->put(item);
//        %%verify result
//        %%verify !multiItemBuffer->isEmpty()
//        %%verify !multiItemBuffer->isFull()
//    }
//    ChannelItem inItem;
//    inItem.asNumber = 3.14;
//    inItem.tag = kDoubleType;
//    result=multiItemBuffer->put(inItem);
//    %%verify result
//    %%verify !multiItemBuffer->isEmpty()
//    %%verify multiItemBuffer->isFull()
//
//    result=multiItemBuffer->put(inItem);
//    %%verify !result
//    %%verify !multiItemBuffer->isEmpty()
//    %%verify multiItemBuffer->isFull()
//


}
void create_workers_Buffers(AvmCore* core) { new ST_workers_Buffers(core); }
}
}
#endif
#endif

// Generated from ST_workers_NoSyncSingleItemBuffer.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
#if !defined DEBUGGER
namespace avmplus {
namespace ST_workers_NoSyncSingleItemBuffer {
class ST_workers_NoSyncSingleItemBuffer : public Selftest {
public:
ST_workers_NoSyncSingleItemBuffer(AvmCore* core);
virtual void run(int n);
virtual void prologue();
virtual void epilogue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
void test1();
void test2();
void test3();
    MMgc::GC *gc;
	NoSyncSingleItemBuffer *buffer;
    Atom *atom;
 
};
ST_workers_NoSyncSingleItemBuffer::ST_workers_NoSyncSingleItemBuffer(AvmCore* core)
    : Selftest(core, "workers", "NoSyncSingleItemBuffer", ST_workers_NoSyncSingleItemBuffer::ST_names,ST_workers_NoSyncSingleItemBuffer::ST_explicits)
{}
const char* ST_workers_NoSyncSingleItemBuffer::ST_names[] = {"constructor","emptyBuffer","fullBuffer","destroy", NULL };
const bool ST_workers_NoSyncSingleItemBuffer::ST_explicits[] = {false,false,false,false, false };
void ST_workers_NoSyncSingleItemBuffer::run(int n) {
switch(n) {
case 0: test0(); return;
case 1: test1(); return;
case 2: test2(); return;
case 3: test3(); return;
}
}
void ST_workers_NoSyncSingleItemBuffer::prologue() {
    gc=core->GetGC();
    atom=(Atom *)malloc(100);
    buffer=new NoSyncSingleItemBuffer(gc);

}
void ST_workers_NoSyncSingleItemBuffer::epilogue() {
	delete buffer;
    free(atom);
	
}

void ST_workers_NoSyncSingleItemBuffer::test0() {
// line 30 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(buffer!=NULL, "buffer!=NULL", __FILE__, __LINE__);
	
}
void ST_workers_NoSyncSingleItemBuffer::test1() {
// line 33 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(buffer->isEmpty(), "buffer->isEmpty()", __FILE__, __LINE__);
// line 34 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(!buffer->isFull(), "!buffer->isFull()", __FILE__, __LINE__);
// line 35 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(!buffer->get(atom), "!buffer->get(atom)", __FILE__, __LINE__);
	
}
void ST_workers_NoSyncSingleItemBuffer::test2() {
    buffer->put(String::createLatin1(core,"test string")->atom());
// line 39 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(!buffer->isEmpty(), "!buffer->isEmpty()", __FILE__, __LINE__);
// line 40 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(buffer->isFull(), "buffer->isFull()", __FILE__, __LINE__);
// line 41 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(buffer->get(atom), "buffer->get(atom)", __FILE__, __LINE__);
// line 42 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(buffer->isEmpty(), "buffer->isEmpty()", __FILE__, __LINE__);
// line 43 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(!buffer->isFull(), "!buffer->isFull()", __FILE__, __LINE__);
	
}
void ST_workers_NoSyncSingleItemBuffer::test3() {
    buffer->unregisterRoot();
// line 47 "ST_workers_NoSyncSingleItemBuffer.st"
verifyPass(true, "true", __FILE__, __LINE__);

	

}
void create_workers_NoSyncSingleItemBuffer(AvmCore* core) { new ST_workers_NoSyncSingleItemBuffer(core); }
}
}
#endif
#endif

// Generated from ST_workers_Promise.st
// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*-
// vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5)
// 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
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include "avmshell.h"
#ifdef VMCFG_SELFTEST
namespace avmplus {
namespace ST_workers_Promise {
class ST_workers_Promise : public Selftest {
public:
ST_workers_Promise(AvmCore* core);
virtual void run(int n);
virtual void prologue();
private:
static const char* ST_names[];
static const bool ST_explicits[];
void test0();
    Isolate *main;

};
ST_workers_Promise::ST_workers_Promise(AvmCore* core)
    : Selftest(core, "workers", "Promise", ST_workers_Promise::ST_names,ST_workers_Promise::ST_explicits)
{}
const char* ST_workers_Promise::ST_names[] = {"MainWorker", NULL };
const bool ST_workers_Promise::ST_explicits[] = {false, false };
void ST_workers_Promise::run(int n) {
switch(n) {
case 0: test0(); return;
}
}
void ST_workers_Promise::prologue() {
    main=core->getIsolate();


}
void ST_workers_Promise::test0() {
    // verify the main worker can be retrieved from AvmCore
// line 19 "ST_workers_Promise.st"
verifyPass(main!=NULL, "main!=NULL", __FILE__, __LINE__);
    uint32_t state=main->getAggregate()->queryState(main);
    // verify state == RUNNING
    //printf("state=%d\n",state);
// line 23 "ST_workers_Promise.st"
verifyPass(state==4, "state==4", __FILE__, __LINE__);

// line 25 "ST_workers_Promise.st"
verifyPass(main->getAvmCore() == core, "main->getAvmCore() == core", __FILE__, __LINE__);
// line 26 "ST_workers_Promise.st"
verifyPass(main->isParentOf(main) == false, "main->isParentOf(main) == false", __FILE__, __LINE__);


}
void create_workers_Promise(AvmCore* core) { new ST_workers_Promise(core); }
}
}
#endif