Пример #1
0
void TestACLsInfer::createMeta()
{
	mCLSID = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mPropIDs[1]);
			lV[1].setParam(0);
			lET = mSession->expr(OP_IN, 2, lV);
		}
		TVERIFYRC(lQ->addCondition(lVar,lET)); lET->destroy();	
		char lB[124]; sprintf(lB, "TestACLsInfer.%s.Family.%d", mClassStr.c_str(), 0);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mCLSID));
	}
	mCLSID2 = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mPropIDs[2]);
			lV[1].setParam(0);
			lET = mSession->expr(OP_IN, 2, lV);
		}
		TVERIFYRC(lQ->addCondition(lVar,lET)); lET->destroy();	
		char lB[124]; sprintf(lB, "TestACLsInfer.%s.Family.%d", mClassStr.c_str(), 1);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mCLSID2));
	}
}
Пример #2
0
void
windowBindingInit(mrb_state *mrb)
{
	RClass *klass = defineClass(mrb, "Window");

	disposableBindingInit     <Window>(mrb, klass);
	viewportElementBindingInit<Window>(mrb, klass);

	mrb_define_method(mrb, klass, "initialize", windowInitialize, MRB_ARGS_REQ(1));
	mrb_define_method(mrb, klass, "update",     windowUpdate,     MRB_ARGS_NONE());

	INIT_PROP_BIND( Window, Windowskin,      "windowskin"       );
	INIT_PROP_BIND( Window, Contents,        "contents"         );
	INIT_PROP_BIND( Window, Stretch,         "stretch"          );
	INIT_PROP_BIND( Window, CursorRect,      "cursor_rect"      );
	INIT_PROP_BIND( Window, Active,          "active"           );
	INIT_PROP_BIND( Window, Pause,           "pause"            );
	INIT_PROP_BIND( Window, X,               "x"                );
	INIT_PROP_BIND( Window, Y,               "y"                );
	INIT_PROP_BIND( Window, Width,           "width"            );
	INIT_PROP_BIND( Window, Height,          "height"           );
	INIT_PROP_BIND( Window, OX,              "ox"               );
	INIT_PROP_BIND( Window, OY,              "oy"               );
	INIT_PROP_BIND( Window, Opacity,         "opacity"          );
	INIT_PROP_BIND( Window, BackOpacity,     "back_opacity"     );
	INIT_PROP_BIND( Window, ContentsOpacity, "contents_opacity" );

	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
}
void testmassiveclassification::defineClasses(int ClassCount)
{
	string strRand ; 
	char * className;
	int i;
	mLogger.out()<<endl<<"Defining "<<COUNT_CLASS<< " classes."<<std::flush;
	long const lBef = getTimeInMs();
	for(i=0;i<ClassCount;i++)
	{
		MVTRand::getString( strRand, 20, 0 ) ;
		char lB[64]; sprintf(lB, "%d.massive.class.%s", i,strRand.c_str());
		className=lB;
		
		IStmt *lClassQ=mSession->createStmt() ;
		unsigned char lVar = lClassQ->addVariable() ;
		Value ops[1] ; 
		ops[0].setVarRef(0, mProp[i] ) ;
		IExprNode *lE=mSession->expr(OP_EXISTS, 1, ops ) ;
		lClassQ->addCondition( lVar, lE ) ;

		TVERIFYRC(defineClass(mSession, lB, lClassQ ));
		lClassQ->destroy();
		lE->destroy();
		if(!(i%100))
			std::cout<<"."<<std::flush;
	}
	mDefineTime = getTimeInMs()-lBef ;
	mLogger.out()<<endl<<"Defining "<<COUNT_CLASS<< " classes done!";
}
Пример #4
0
void listInit(void* state){
	VirtualMachine *vm = (VirtualMachine*)state;
	ClsType* cls = defineClass(state, "list");
	vm->listCls = cls;
	assert(cls != NULL);
	defineClassMethod(state, cls, "constructor", listNew, ANYARG);
	defineClassMethod(state, cls, "[]", listGet, 2);
	defineClassMethod(state, cls, "[]=", listSet, 3);
	defineClassMethod(state, cls, "str", listStr, 1);
	defineClassMethod(state, cls, "len", listLen, 1);
	defineClassMethod(state, cls, "append", listAppend, ANYARG);
}
Пример #5
0
JavaClass *JNIKit::defineClass(string name, string filename, jobject classLoader) {
	// Load the file data
	std::ifstream file(filename, std::ios::binary);
	file.seekg(0, std::ios::end);
	std::streamsize size = file.tellg();
	file.seekg(0, std::ios::beg);

	std::vector<char> buffer(size);
	if (!file.read(buffer.data(), size)) {
		throw JNIError("could not read file contents into buffer");
	}

	// Construct new class from data buffer
	return defineClass(name, buffer, classLoader);
}
Пример #6
0
void TestFamilyOrder::createFamily(unsigned int flag)
{
	IStmt *lFamilyQ = mSession->createStmt();
	unsigned char lVar = lFamilyQ->addVariable() ;
	Value ops[2] ; 

	ops[0].setVarRef(lVar, mPropIDs[0]);
	ops[1].setParam(0);
	IExprNode *lE = mSession->expr(OP_BEGINS, 2, ops, flag);
	lFamilyQ->addCondition( lVar, lE ) ;
	Tstring randStr;
	MVTApp::randomString(randStr,10,20);
	randStr += ".family";
	fID = STORE_INVALID_CLASSID;
	TVERIFYRC(defineClass(mSession, randStr.c_str(), lFamilyQ, &fID));
	lFamilyQ->destroy();
}
Пример #7
0
	// Attempt to repro an issue in the app with IPC - no success yet
	// (even running the test multiple times concurrently).
	THREAD_SIGNATURE threadTestStreamsBashQuery(void * pStop)
	{
		ISession * const lSession =	MVTApp::startSession();

		// Define a class of all pins created by this test.
		DataEventID lClsid;
		if (RC_OK != lSession->getDataEventID("teststreams.bashquery", lClsid))
		{
			IStmt * const lQClass = lSession->createStmt();
			unsigned char const lVarClass = lQClass->addVariable();
			PropertyID const lPropIDsClass[] = {1000};
			lQClass->setPropCondition(lVarClass, lPropIDsClass, 1);
			defineClass(lSession,"teststreams.bashquery", lQClass, &lClsid);
			lQClass->destroy();
		}

		// Define a query for this class.
		IStmt * const lQ = lSession->createStmt();
		SourceSpec lCS;
		lCS.objectID = lClsid;
		lCS.nParams = 0;
		lCS.params = NULL;
		lQ->addVariable(&lCS, 1);

		// Periodically query the pins, while the test creates them.
		int j;
		long volatile & lStop = *(long volatile *)pStop;
		for (j = 0; j < 5000 && 0 == lStop; j++)
		{
			ICursor * lR = lQ->execute();
			IPIN * lP;
			for (lP = lR ? lR->next() : NULL; lP; lP = lR->next()) { lP->destroy(); }
			lR->destroy();

			Sleep(100);
		}
		lQ->destroy();
		lSession->terminate();
		return 0;
	}
Пример #8
0
void
planeBindingInit(mrb_state *mrb)
{
	RClass *klass = defineClass(mrb, "Plane");

	disposableBindingInit<Plane>     (mrb, klass);
	viewportElementBindingInit<Plane>(mrb, klass);

	mrb_define_method(mrb, klass, "initialize", planeInitialize, MRB_ARGS_OPT(1));

	INIT_PROP_BIND( Plane, Bitmap,    "bitmap"     );
	INIT_PROP_BIND( Plane, OX,        "ox"         );
	INIT_PROP_BIND( Plane, OY,        "oy"         );
	INIT_PROP_BIND( Plane, ZoomX,     "zoom_x"     );
	INIT_PROP_BIND( Plane, ZoomY,     "zoom_y"     );
	INIT_PROP_BIND( Plane, Opacity,   "opacity"    );
	INIT_PROP_BIND( Plane, BlendType, "blend_type" );
	INIT_PROP_BIND( Plane, Color,     "color"      );
	INIT_PROP_BIND( Plane, Tone,      "tone"       );

	mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
}
Пример #9
0
void wrenInitializeCore(WrenVM* vm)
{
  ObjModule* coreModule = wrenNewModule(vm, NULL);
  wrenPushRoot(vm, (Obj*)coreModule);
  
  // The core module's key is null in the module map.
  wrenMapSet(vm, vm->modules, NULL_VAL, OBJ_VAL(coreModule));
  wrenPopRoot(vm); // coreModule.

  // Define the root Object class. This has to be done a little specially
  // because it has no superclass.
  vm->objectClass = defineClass(vm, coreModule, "Object");
  PRIMITIVE(vm->objectClass, "!", object_not);
  PRIMITIVE(vm->objectClass, "==(_)", object_eqeq);
  PRIMITIVE(vm->objectClass, "!=(_)", object_bangeq);
  PRIMITIVE(vm->objectClass, "is(_)", object_is);
  PRIMITIVE(vm->objectClass, "toString", object_toString);
  PRIMITIVE(vm->objectClass, "type", object_type);

  // Now we can define Class, which is a subclass of Object.
  vm->classClass = defineClass(vm, coreModule, "Class");
  wrenBindSuperclass(vm, vm->classClass, vm->objectClass);
  PRIMITIVE(vm->classClass, "name", class_name);
  PRIMITIVE(vm->classClass, "supertype", class_supertype);
  PRIMITIVE(vm->classClass, "toString", class_toString);

  // Finally, we can define Object's metaclass which is a subclass of Class.
  ObjClass* objectMetaclass = defineClass(vm, coreModule, "Object metaclass");

  // Wire up the metaclass relationships now that all three classes are built.
  vm->objectClass->obj.classObj = objectMetaclass;
  objectMetaclass->obj.classObj = vm->classClass;
  vm->classClass->obj.classObj = vm->classClass;

  // Do this after wiring up the metaclasses so objectMetaclass doesn't get
  // collected.
  wrenBindSuperclass(vm, objectMetaclass, vm->classClass);

  PRIMITIVE(objectMetaclass, "same(_,_)", object_same);

  // The core class diagram ends up looking like this, where single lines point
  // to a class's superclass, and double lines point to its metaclass:
  //
  //        .------------------------------------. .====.
  //        |                  .---------------. | #    #
  //        v                  |               v | v    #
  //   .---------.   .-------------------.   .-------.  #
  //   | Object  |==>| Object metaclass  |==>| Class |=="
  //   '---------'   '-------------------'   '-------'
  //        ^                                 ^ ^ ^ ^
  //        |                  .--------------' # | #
  //        |                  |                # | #
  //   .---------.   .-------------------.      # | # -.
  //   |  Base   |==>|  Base metaclass   |======" | #  |
  //   '---------'   '-------------------'        | #  |
  //        ^                                     | #  |
  //        |                  .------------------' #  | Example classes
  //        |                  |                    #  |
  //   .---------.   .-------------------.          #  |
  //   | Derived |==>| Derived metaclass |=========="  |
  //   '---------'   '-------------------'            -'

  // The rest of the classes can now be defined normally.
  wrenInterpretInModule(vm, NULL, coreModuleSource);

  vm->boolClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Bool"));
  PRIMITIVE(vm->boolClass, "toString", bool_toString);
  PRIMITIVE(vm->boolClass, "!", bool_not);

  vm->fiberClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Fiber"));
  PRIMITIVE(vm->fiberClass->obj.classObj, "new(_)", fiber_new);
  PRIMITIVE(vm->fiberClass->obj.classObj, "abort(_)", fiber_abort);
  PRIMITIVE(vm->fiberClass->obj.classObj, "current", fiber_current);
  PRIMITIVE(vm->fiberClass->obj.classObj, "suspend()", fiber_suspend);
  PRIMITIVE(vm->fiberClass->obj.classObj, "yield()", fiber_yield);
  PRIMITIVE(vm->fiberClass->obj.classObj, "yield(_)", fiber_yield1);
  PRIMITIVE(vm->fiberClass, "call()", fiber_call);
  PRIMITIVE(vm->fiberClass, "call(_)", fiber_call1);
  PRIMITIVE(vm->fiberClass, "error", fiber_error);
  PRIMITIVE(vm->fiberClass, "isDone", fiber_isDone);
  PRIMITIVE(vm->fiberClass, "transfer()", fiber_transfer);
  PRIMITIVE(vm->fiberClass, "transfer(_)", fiber_transfer1);
  PRIMITIVE(vm->fiberClass, "transferError(_)", fiber_transferError);
  PRIMITIVE(vm->fiberClass, "try()", fiber_try);

  vm->fnClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Fn"));
  PRIMITIVE(vm->fnClass->obj.classObj, "new(_)", fn_new);

  PRIMITIVE(vm->fnClass, "arity", fn_arity);
  fnCall(vm, "call()");
  fnCall(vm, "call(_)");
  fnCall(vm, "call(_,_)");
  fnCall(vm, "call(_,_,_)");
  fnCall(vm, "call(_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_,_,_,_,_,_)");
  fnCall(vm, "call(_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_)");
  PRIMITIVE(vm->fnClass, "toString", fn_toString);

  vm->nullClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Null"));
  PRIMITIVE(vm->nullClass, "!", null_not);
  PRIMITIVE(vm->nullClass, "toString", null_toString);

  vm->numClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Num"));
  PRIMITIVE(vm->numClass->obj.classObj, "fromString(_)", num_fromString);
  PRIMITIVE(vm->numClass->obj.classObj, "pi", num_pi);
  PRIMITIVE(vm->numClass, "-(_)", num_minus);
  PRIMITIVE(vm->numClass, "+(_)", num_plus);
  PRIMITIVE(vm->numClass, "*(_)", num_multiply);
  PRIMITIVE(vm->numClass, "/(_)", num_divide);
  PRIMITIVE(vm->numClass, "<(_)", num_lt);
  PRIMITIVE(vm->numClass, ">(_)", num_gt);
  PRIMITIVE(vm->numClass, "<=(_)", num_lte);
  PRIMITIVE(vm->numClass, ">=(_)", num_gte);
  PRIMITIVE(vm->numClass, "&(_)", num_bitwiseAnd);
  PRIMITIVE(vm->numClass, "|(_)", num_bitwiseOr);
  PRIMITIVE(vm->numClass, "^(_)", num_bitwiseXor);
  PRIMITIVE(vm->numClass, "<<(_)", num_bitwiseLeftShift);
  PRIMITIVE(vm->numClass, ">>(_)", num_bitwiseRightShift);
  PRIMITIVE(vm->numClass, "abs", num_abs);
  PRIMITIVE(vm->numClass, "acos", num_acos);
  PRIMITIVE(vm->numClass, "asin", num_asin);
  PRIMITIVE(vm->numClass, "atan", num_atan);
  PRIMITIVE(vm->numClass, "ceil", num_ceil);
  PRIMITIVE(vm->numClass, "cos", num_cos);
  PRIMITIVE(vm->numClass, "floor", num_floor);
  PRIMITIVE(vm->numClass, "-", num_negate);
  PRIMITIVE(vm->numClass, "sin", num_sin);
  PRIMITIVE(vm->numClass, "sqrt", num_sqrt);
  PRIMITIVE(vm->numClass, "tan", num_tan);
  PRIMITIVE(vm->numClass, "%(_)", num_mod);
  PRIMITIVE(vm->numClass, "~", num_bitwiseNot);
  PRIMITIVE(vm->numClass, "..(_)", num_dotDot);
  PRIMITIVE(vm->numClass, "...(_)", num_dotDotDot);
  PRIMITIVE(vm->numClass, "atan(_)", num_atan2);
  PRIMITIVE(vm->numClass, "fraction", num_fraction);
  PRIMITIVE(vm->numClass, "isInfinity", num_isInfinity);
  PRIMITIVE(vm->numClass, "isInteger", num_isInteger);
  PRIMITIVE(vm->numClass, "isNan", num_isNan);
  PRIMITIVE(vm->numClass, "sign", num_sign);
  PRIMITIVE(vm->numClass, "toString", num_toString);
  PRIMITIVE(vm->numClass, "truncate", num_truncate);

  // These are defined just so that 0 and -0 are equal, which is specified by
  // IEEE 754 even though they have different bit representations.
  PRIMITIVE(vm->numClass, "==(_)", num_eqeq);
  PRIMITIVE(vm->numClass, "!=(_)", num_bangeq);

  vm->stringClass = AS_CLASS(wrenFindVariable(vm, coreModule, "String"));
  PRIMITIVE(vm->stringClass->obj.classObj, "fromCodePoint(_)", string_fromCodePoint);
  PRIMITIVE(vm->stringClass, "+(_)", string_plus);
  PRIMITIVE(vm->stringClass, "[_]", string_subscript);
  PRIMITIVE(vm->stringClass, "byteAt_(_)", string_byteAt);
  PRIMITIVE(vm->stringClass, "byteCount_", string_byteCount);
  PRIMITIVE(vm->stringClass, "codePointAt_(_)", string_codePointAt);
  PRIMITIVE(vm->stringClass, "contains(_)", string_contains);
  PRIMITIVE(vm->stringClass, "endsWith(_)", string_endsWith);
  PRIMITIVE(vm->stringClass, "indexOf(_)", string_indexOf);
  PRIMITIVE(vm->stringClass, "iterate(_)", string_iterate);
  PRIMITIVE(vm->stringClass, "iterateByte_(_)", string_iterateByte);
  PRIMITIVE(vm->stringClass, "iteratorValue(_)", string_iteratorValue);
  PRIMITIVE(vm->stringClass, "startsWith(_)", string_startsWith);
  PRIMITIVE(vm->stringClass, "toString", string_toString);

  vm->listClass = AS_CLASS(wrenFindVariable(vm, coreModule, "List"));
  PRIMITIVE(vm->listClass->obj.classObj, "new()", list_new);
  PRIMITIVE(vm->listClass, "[_]", list_subscript);
  PRIMITIVE(vm->listClass, "[_]=(_)", list_subscriptSetter);
  PRIMITIVE(vm->listClass, "add(_)", list_add);
  PRIMITIVE(vm->listClass, "addCore_(_)", list_addCore);
  PRIMITIVE(vm->listClass, "clear()", list_clear);
  PRIMITIVE(vm->listClass, "count", list_count);
  PRIMITIVE(vm->listClass, "insert(_,_)", list_insert);
  PRIMITIVE(vm->listClass, "iterate(_)", list_iterate);
  PRIMITIVE(vm->listClass, "iteratorValue(_)", list_iteratorValue);
  PRIMITIVE(vm->listClass, "removeAt(_)", list_removeAt);

  vm->mapClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Map"));
  PRIMITIVE(vm->mapClass->obj.classObj, "new()", map_new);
  PRIMITIVE(vm->mapClass, "[_]", map_subscript);
  PRIMITIVE(vm->mapClass, "[_]=(_)", map_subscriptSetter);
  PRIMITIVE(vm->mapClass, "addCore_(_,_)", map_addCore);
  PRIMITIVE(vm->mapClass, "clear()", map_clear);
  PRIMITIVE(vm->mapClass, "containsKey(_)", map_containsKey);
  PRIMITIVE(vm->mapClass, "count", map_count);
  PRIMITIVE(vm->mapClass, "remove(_)", map_remove);
  PRIMITIVE(vm->mapClass, "iterate_(_)", map_iterate);
  PRIMITIVE(vm->mapClass, "keyIteratorValue_(_)", map_keyIteratorValue);
  PRIMITIVE(vm->mapClass, "valueIteratorValue_(_)", map_valueIteratorValue);

  vm->rangeClass = AS_CLASS(wrenFindVariable(vm, coreModule, "Range"));
  PRIMITIVE(vm->rangeClass, "from", range_from);
  PRIMITIVE(vm->rangeClass, "to", range_to);
  PRIMITIVE(vm->rangeClass, "min", range_min);
  PRIMITIVE(vm->rangeClass, "max", range_max);
  PRIMITIVE(vm->rangeClass, "isInclusive", range_isInclusive);
  PRIMITIVE(vm->rangeClass, "iterate(_)", range_iterate);
  PRIMITIVE(vm->rangeClass, "iteratorValue(_)", range_iteratorValue);
  PRIMITIVE(vm->rangeClass, "toString", range_toString);

  ObjClass* systemClass = AS_CLASS(wrenFindVariable(vm, coreModule, "System"));
  PRIMITIVE(systemClass->obj.classObj, "clock", system_clock);
  PRIMITIVE(systemClass->obj.classObj, "gc()", system_gc);
  // TODO: Do we want to give these magic names that can't be called from
  // regular code?
  PRIMITIVE(systemClass->obj.classObj, "getModuleVariable(_,_)", system_getModuleVariable);
  PRIMITIVE(systemClass->obj.classObj, "importModule(_)", system_importModule);
  PRIMITIVE(systemClass->obj.classObj, "writeString_(_)", system_writeString);

  // While bootstrapping the core types and running the core module, a number
  // of string objects have been created, many of which were instantiated
  // before stringClass was stored in the VM. Some of them *must* be created
  // first -- the ObjClass for string itself has a reference to the ObjString
  // for its name.
  //
  // These all currently have a NULL classObj pointer, so go back and assign
  // them now that the string class is known.
  for (Obj* obj = vm->first; obj != NULL; obj = obj->next)
  {
    if (obj->type == OBJ_STRING) obj->classObj = vm->stringClass;
  }
}
Пример #10
0
int testjoinorderby::execute()
{
	ISession * mSession ;int i;
	if (!MVTApp::startStore()) {mLogger.print("Failed to start store\n"); return RC_NOACCESS;}
	mSession = MVTApp::startSession();
	
	//Properties - mapping properties
	PropertyID date_original_modifiedPropID;
	char *propName2;char lB[64]; sprintf(lB, "http://vmware.com/core/date_original_modified");propName2=lB;
	date_original_modifiedPropID=MVTUtil::getPropRand(mSession,propName2);
	for(i=0;i<6;i++)		
	{
		char lB[64]; sprintf(lB, "%d.propery", i);
		propName2=lB;
		mProp[i]=MVTUtil::getPropRand(mSession,propName2);
	}
	//DEfining Classes
	const char *lClassList[] = {"unprocessedAudioMP31","unprocessedMeta1","unprocessedPDF1","unprocessedDocx1","unprocessedTXT1"};
	const char *lClassList2[] = {"hostingPinsPushShredder","hostingPinsNotShredded1"};
	size_t nClasses = sizeof(lClassList)/sizeof(lClassList[0]);
	for(i=0;i<6;i++)
	{
		IStmt *lFamilyQ=mSession->createStmt() ;
		unsigned char lVar = lFamilyQ->addVariable() ;
		Value ops[2] ;
		Value ops1[1] ;
		Value ops2[2] ;
		ops[0].setVarRef(0, date_original_modifiedPropID ) ;ops[1].setParam(0);
		IExprNode *lE= mSession->expr(OP_IN, 2, ops )  ;
		ops1[0].setVarRef(0, mProp[i] ) ;
		IExprNode *lE1= mSession->expr(OP_EXISTS, 1, ops1 )  ;
		ops2[0].set(lE);
		ops2[1].set(lE1);
		IExprNode *lE2= mSession->expr(OP_LAND, 2, ops2 ) ;
		TVERIFYRC(lFamilyQ->addCondition( lVar, lE2 )) ;
		if(i<4)
		{
			TVERIFYRC(defineClass(mSession, lClassList[i], lFamilyQ ));
		}
		else
		{
			TVERIFYRC(defineClass(mSession, lClassList2[i-4], lFamilyQ ));
		}
		lE2->destroy();
		lFamilyQ->destroy();
	}

	//Creating Pins
	{
	Value lV[7];
	TIMESTAMP lTS;
	for(i=0;i<15;i++)
	{
		lTS=MVTRand::getDateTime(mSession);
		lV[0].setDateTime(lTS);lV[0].setPropID(date_original_modifiedPropID);
		lV[1].setDateTime(lTS);lV[1].property=mProp[0];
		lV[2].setDateTime(lTS);lV[2].property=mProp[1];
		lV[3].setDateTime(lTS);lV[3].property=mProp[2];
		lV[4].setDateTime(lTS);lV[4].property=mProp[3];
		lV[5].setDateTime(lTS);lV[5].property=mProp[4];
		lV[6].setDateTime(lTS);lV[6].property=mProp[5];
		TVERIFYRC(mSession->createPIN(lV,7,NULL,MODE_COPY_VALUES|MODE_PERSISTENT));	
	}
	}
	//Query
	IStmt *lQuery = mSession->createStmt();
	//union of four classes
	RC rc = RC_OK;
	if(lQuery)
	{
		unsigned char lastvar = 0;bool bSuccess = true;
		for(unsigned long iidx = 0 ; iidx < nClasses && bSuccess; iidx++)
		{
			Afy::SourceSpec lclassSpec;
			lclassSpec.nParams=0;
			lclassSpec.params=NULL;
			if(RC_OK == (rc = mSession->getDataEventID(lClassList[iidx],lclassSpec.objectID)))
			{
				unsigned char tmpVar = lQuery->addVariable(&lclassSpec,1); 
				lastvar = iidx==0 ? tmpVar : lQuery->setOp(lastvar,tmpVar,Afy::QRY_UNION);
			}
			else 
				bSuccess = false;
		}
	//intersection of fifth class
		Afy::Value lrange[2];Afy::Value lparam;
		if(bSuccess)
		{
			Afy::SourceSpec lclassSpec;
			if( RC_OK == (rc =mSession->getDataEventID("hostingPinsPushShredder",lclassSpec.objectID)))
			{
				lclassSpec.nParams=0;
				lclassSpec.params=NULL;
				unsigned char tmpVar = lQuery->addVariable(&lclassSpec,1); 
				lastvar = lQuery->setOp(lastvar,tmpVar,Afy::QRY_INTERSECT);
				if( RC_OK == (rc =mSession->getDataEventID("hostingPinsNotShredded1",lclassSpec.objectID)))
				{
					TIMESTAMP lTS;getTimestamp(lTS);
					DateTime lDT;mSession->convDateTime(lTS,lDT,true/*UTC*/);	
					lrange[0].setDateTime(0);
					lrange[1].setDateTime(lTS);
					lparam.setRange(lrange);
					lclassSpec.nParams=1;
					lclassSpec.params=&lparam;
					tmpVar = lQuery->addVariable(&lclassSpec,1); 
					lastvar = lQuery->setOp(lastvar,tmpVar,Afy::QRY_UNION);
				}
				else
					bSuccess = false;
			}
			else
					bSuccess = false;
		}
		OrderSeg ord = {NULL,date_original_modifiedPropID,ORD_DESC,0,0};
		TVERIFYRC(lQuery->setOrder( &ord,1));
		
	//Execution
		int ncount=9;
		Afy::ICursor *lResult = NULL;
		TVERIFYRC(lQuery->execute(&lResult,NULL, 0,(unsigned int)ncount,0)) ;
		//Afy::ICursor *lResult = lQuery->execute();
		IPIN *pin;
		const Value * rV;
		uint16_t tempYear=0; i=0;
		while( pin = lResult->next() )
		{
			DateTime lDT2;
			rV=pin->getValue(date_original_modifiedPropID);
			TVERIFYRC(mSession->convDateTime(rV->ui64,lDT2));
			if(i!=0)
			{
				TVERIFY(lDT2.year<=tempYear);
			}
			tempYear=lDT2.year;i++;
		}
		
	}
	lQuery->destroy();
	mSession->terminate();
	MVTApp::stopStore();
	return RC_OK;
}
Пример #11
0
void TestLeftJoin::createMeta()
{
	// Family #0
	DataEventID lLHSFamilyID = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mLHSPropID);
			lV[1].setParam(0);
			lET = mSession->expr(OP_EQ, 2, lV, CASE_INSENSITIVE_OP);
		}
		lQ->addCondition(lVar,lET);			
		char lB[64];			
		sprintf(lB, "TestLeftJoin.%s.Family%d", mClassStr.c_str(), 0);
		if(RC_OK!=defineClass(mSession,lB, lQ, &lLHSFamilyID)){
			mLogger.out() << "ERROR(TestLeftJoin): Failed to create Family " << lB << std::endl;					
		}
	}

	// Family #1
	DataEventID lRHSFamilyID = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mRHSPropID);
			lV[1].setParam(0);
			lET = mSession->expr(OP_EQ, 2, lV, CASE_INSENSITIVE_OP);
		}
		lQ->addCondition(lVar,lET);			
		char lB[64];			
		sprintf(lB, "TestLeftJoin.%s.Family%d", mClassStr.c_str(), 1);
		if(RC_OK!=defineClass(mSession,lB, lQ, &lRHSFamilyID)){
			mLogger.out() << "ERROR(TestLeftJoin): Failed to create Family " << lB << std::endl;					
		}
	}
	
	// Family #2
	DataEventID lLHSFamilyID2 = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mLHSPropID);
			lV[1].setParam(0);
			lET = mSession->expr(OP_IN, 2, lV, CASE_INSENSITIVE_OP);
		}
		lQ->addCondition(lVar,lET);			
		char lB[64];			
		sprintf(lB, "TestLeftJoin.%s.Family%d", mClassStr.c_str(), 2);
		if(RC_OK!=defineClass(mSession,lB, lQ, &lLHSFamilyID2)){
			mLogger.out() << "ERROR(TestLeftJoin): Failed to create Family " << lB << std::endl;					
		}
	}

	// Family #3
	DataEventID lRHSFamilyID2 = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mRHSPropID);
			lV[1].setParam(0);
			lET = mSession->expr(OP_IN, 2, lV, CASE_INSENSITIVE_OP);
		}
		lQ->addCondition(lVar,lET);			
		char lB[64];			
		sprintf(lB, "TestLeftJoin.%s.Family%d", mClassStr.c_str(), 3);
		if(RC_OK!=defineClass(mSession,lB, lQ, &lRHSFamilyID2)){
			mLogger.out() << "ERROR(TestLeftJoin): Failed to create Family " << lB << std::endl;					
		}
	}

	// Family #4
	DataEventID lLHSFamilyID3 = STORE_INVALID_CLASSID;
	{
		IStmt *lQ = mSession->createStmt();
		unsigned char lVar = lQ->addVariable();
		IExprNode *lET;
		{
			Value lV[2];
			lV[0].setVarRef(0,mRefPropID);
			lV[1].setParam(0);
			lET = mSession->expr(OP_EQ, 2, lV, CASE_INSENSITIVE_OP);
		}
		lQ->addCondition(lVar,lET);			
		char lB[64];			
		sprintf(lB, "TestLeftJoin.%s.Family%d", mClassStr.c_str(), 4);
		if(RC_OK!=defineClass(mSession,lB, lQ, &lLHSFamilyID3)){
			mLogger.out() << "ERROR(TestLeftJoin): Failed to create Family " << lB << std::endl;					
		}
	}
}
Пример #12
0
/*
 * Create a Class and Family to query for deleted PINs
 *
 */
void TestUndelete::createMeta()
{
	// Create a Family
	Tstring lRandStr; MVTRand::getString(lRandStr, 10, 0, false, false);
	{
		CmvautoPtr<IStmt> lQ(mSession->createStmt());
		unsigned const char lVar = lQ->addVariable();
		Value lV[2];
		lV[0].setVarRef(0,mPropIDs[0]);
		lV[1].setParam(0);
		CmvautoPtr<IExprNode> lET(mSession->expr(OP_BEGINS, 2, lV));
		TVERIFYRC(lQ->addCondition(lVar,lET));

		char lB[64]; sprintf(lB, "TestUndelete.%s.%d", lRandStr.c_str(), 0);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mFamilyID));
	}

	// Create a Family on PIN Index aka prop1
	{
		CmvautoPtr<IStmt> lQ(mSession->createStmt());
		unsigned const char lVar = lQ->addVariable();
		Value lV[2];
		lV[0].setVarRef(0,mPropIDs[1]);
		lV[1].setParam(0);
		CmvautoPtr<IExprNode> lET(mSession->expr(OP_EQ, 2, lV));
		TVERIFYRC(lQ->addCondition(lVar,lET));

		char lB[64]; sprintf(lB, "TestUndelete.%s.%d", lRandStr.c_str(), 1);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mFamilyID1));
	}

	// Create a Family on prop2
	{
		CmvautoPtr<IStmt> lQ(mSession->createStmt());
		unsigned const char lVar = lQ->addVariable();
		Value lV[2];
		lV[0].setVarRef(0,mPropIDs[2]);
		lV[1].setParam(0);
		CmvautoPtr<IExprNode> lET(mSession->expr(OP_EQ, 2, lV));
		TVERIFYRC(lQ->addCondition(lVar,lET));

		char lB[64]; sprintf(lB, "TestUndelete.%s.%d", lRandStr.c_str(), 2);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mFamilyID2));
	}

	// Create a Class
	{
		CmvautoPtr<IStmt> lQ(mSession->createStmt());
		unsigned const char lVar = lQ->addVariable();
		Value lV[1];
		lV[0].setVarRef(0,mPropIDs[2]);
		CmvautoPtr<IExprNode> lET(mSession->expr(OP_EXISTS, 1, lV));
		TVERIFYRC(lQ->addCondition(lVar,lET));

		char lB[64]; sprintf(lB, "TestUndelete.%s.%d", lRandStr.c_str(), 3);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mCLSID));
	}
	// Create a family for specific case purge after undelete
	{
		CmvautoPtr<IStmt> lQ(mSession->createStmt());
		unsigned const char lVar = lQ->addVariable();
		Value lV[2];
		lV[0].setVarRef(0,mPropIDs[3]);
		lV[1].setParam(0);
		CmvautoPtr<IExprNode> lET(mSession->expr(OP_EQ, 2, lV));
		TVERIFYRC(lQ->addCondition(lVar,lET));

		char lB[64]; sprintf(lB, "TestUndelete.%s.%d", lRandStr.c_str(), 4);
		TVERIFYRC(defineClass(mSession,lB, lQ, &mFamilyID3));
	}
}
// Implement this test.
int TestMergeCollections::execute()
{
	bool lSuccess =	true;
	if (MVTApp::startStore())
	{
		ISession * const lSession =	MVTApp::startSession();

		// Declare properties.
		URIMap	lData[2];
		MVTApp::mapURIs(lSession,"TestMergeCollections.prop",2,lData);
		PropertyID const lPropIdVal    = lData[0].uid;
		PropertyID const lPropIdRef    = lData[1].uid;
		PropertyID const lPropIdPinId  = PROP_SPEC_PINID;

		DataEventID lClassVal = STORE_INVALID_CLASSID;
		{
			char lB[100]; sprintf(lB,"TestMergeCollections.ClassVal.%d",rand());
			Value lV[2]; 
			lV[0].setVarRef(0,lPropIdVal);
			lV[1].setParam(0);
			IExprNode *expr=lSession->expr(OP_LT,2,lV);
			IStmt *lQ = lSession->createStmt();
			lQ->addVariable(NULL,0,expr);
			TVERIFYRC(defineClass(lSession,lB,lQ,&lClassVal));
			lQ->destroy();
		}

		DataEventID lClassRef = STORE_INVALID_CLASSID;
		{
			char lB[100]; sprintf(lB,"TestMergeCollections.ClassRef.%d",rand());
			IStmt *lQ = lSession->createStmt();
			lQ->addVariable();
			lQ->setPropCondition(0,&lPropIdRef,1);
			TVERIFYRC(defineClass(lSession,lB,lQ,&lClassRef));
			lQ->destroy();
		}

		/**
		* The following creates the family on reference class...
		**/		
		DataEventID lClassFamilyOnRef = STORE_INVALID_CLASSID;
		{
			char lB[100]; sprintf(lB,"TestMergeCollections.ClassFamilyOnRef.%d",rand());
			Value lVFoR[2];
			lVFoR[0].setVarRef(0,lPropIdRef);
			lVFoR[1].setParam(0);
			IExprNode *expr=lSession->expr(OP_IN,2,lVFoR);
			IStmt *lQ = lSession->createStmt();
			lQ->addVariable(NULL,0,expr);
			TVERIFYRC(defineClass(lSession,lB,lQ,&lClassFamilyOnRef));
			lQ->destroy();
		}

		// Create a few pins
		mLogger.out() << "Creating " << NPINS*2 << " pins... ";

		PID pins[NPINS]; bool lfMember[NPINS];
		PID refferedPins[NPINS];

		//Creating first group of pins: 
		// - each pin may have an interger value, or collection of interger values; 
		// - each pin may have the same interger value within collection; 
		// - if at least one of the values within pin < treshold, it should be picked up by the family... 		
		const int threshold = RANGE/3; int i;
		if(isVerbose()) mLogger.out() << " List of PINs with value less than threshold " << std::endl;
		for (i = 0; i < NPINS; i++)
		{
			Value lV[2]; 
			int val = MVTRand::getRange(0, RANGE);
			lfMember[i] = val < threshold;
			SETVALUE(lV[0], lPropIdVal, val, OP_SET);
			CREATEPIN(lSession, &pins[i], lV, 1);
                        
			IPIN *ppin = lSession->getPIN(pins[i]);
			int elemincollection = MVTRand::getRange(1, MAX_ELEM_INCOLLECTION);
			for(int jj = 0; jj < elemincollection; jj++)
			{
				int val2 = MVTRand::getRange(1, RANGE);
				if(!lfMember[i] && (val2 < threshold)) 
					lfMember[i] = true;
				SETVALUE_C(lV[0], lPropIdVal, val2, OP_ADD, STORE_LAST_ELEMENT);
				TVERIFYRC(ppin->modify(lV,1));
			}
			if(isVerbose() && lfMember[i]) mLogger.out() << std::hex <<  pins[i].pid << std::endl;
			ppin->destroy();
		}

		// Create second group of pins:
		//  - each pin within that group has either reference or collection of references 
		//    to a random pin(s) in the set above
		//  - the reference to the pin, which value < threshold may be within any position within collection; 
		//  - it may be multiple references to the same pin, including the pin which value < threshold; 		
		if(isVerbose()) mLogger.out() << " List of PINs with refs whose value is less than threshold " << std::endl;
		int lCount = 0; 
		int lCountDiff = 0; //counts how many pins with value < threshold has been added while creating collection... 
		for (i = 0; i < NPINS; i++)
		{
			PID lReferPID;
			INITLOCALPID(lReferPID); lReferPID.pid = STORE_INVALID_PID;
			Value lV[2]; 
			int idx = MVTRand::getRange(0, NPINS-1); 
			PID id; bool willbefound = false;
			if (lfMember[idx])
			{ 
				lCount++; 
				willbefound = true; // The referenced pin will match the family query
				lReferPID = pins[idx];
			} 
			SETVALUE(lV[0], lPropIdRef, pins[idx], OP_SET); 
			refferedPins[i] = pins[idx];    // to remember reffered pins;
			CREATEPIN(lSession, &id, lV, 1);

			IPIN *ppin = lSession->getPIN(id);
			int elemincollection = MVTRand::getRange(1, MAX_ELEM_INCOLLECTION);
			for(int jj = 0; jj < elemincollection; jj++)
			{
				int idx1 = MVTRand::getRange(0, NPINS-1);
				SETVALUE_C(lV[0], lPropIdRef, pins[idx1], OP_ADD, STORE_LAST_ELEMENT); 
				TVERIFYRC(ppin->modify(lV,1));

				if(!willbefound && lfMember[idx1])
				{ 
					lCount++; willbefound = true; 
					lReferPID = pins[idx1];
					lCountDiff++; 
				}  
			}
			if(isVerbose() && willbefound) mLogger.out() << std::hex << id.pid << " with ref to " << lReferPID.pid << std::endl;
			ppin->destroy();
		}
		
		mLogger.out() << std::dec << "DONE" << std::endl;
		
		// Do a simple join search.
		// " All pins from lClassFamilyOnRef Family, where any of the PINs in lPropIdRef has (lPropIdVal < threshhold)
		
		// "All pins, from lClassRef class, where the lPropIdRef property is equal 
		// to the PROP_SPEC_PINID of a PIN matching the lClassVal query of (lPropIdVal < threshhold)"
		// 
		IStmt *lQ	= lSession->createStmt();
		
		Value lV[4]; 
		lV[0].setError(lPropIdRef); lV[1].setError(lPropIdRef); lV[2].setRange(&lV[0]);
		lV[3].set(threshold); // Family query will find all pins with lPropIdVal < threshhold

		SourceSpec classSpec[2]={{lClassFamilyOnRef,1,&lV[2]},{lClassVal,1,&lV[3]}};		
		unsigned char lVar1 = lQ->addVariable(&classSpec[0],1),lVar2 = lQ->addVariable(&classSpec[1],1);

		lV[0].setVarRef(lVar1,lPropIdRef);
		lV[1].setVarRef(lVar2,lPropIdPinId);
		IExprNode *expr = lSession->expr(OP_EQ,2,lV);
		lQ->join(lVar1,lVar2,expr);
		OrderSeg ord={NULL,lPropIdRef,0,0,0};
		lQ->setOrder(&ord,1);

		uint64_t lCnt = 0;
		TVERIFYRC(lQ->count(lCnt,NULL,0,~0u));

		TVERIFY((int)lCnt == lCount);
		
		{
			mLogger.out() << "Count returned = " << lCnt << ";  Expected Count = " << lCount << "; lCountDiff = " << lCountDiff << ";" <<  std::endl;

			//The query below - attempt to find how many pins with at least one value < threshold were found by Family...
			mLogger.out() << "The query below - attempt to find how many pins with at least one value < threshold were found by Family..." << std::endl; 
			IStmt *lQFamily = lSession->createStmt(); 
			lQFamily->addVariable(&classSpec[1],1);
			uint64_t lCntFFound = 0;
			TVERIFYRC(lQFamily->count(lCntFFound));
			mLogger.out() << "lCntFFound= " << lCntFFound << ";" << std::endl;
			lQFamily->destroy();
		}  
		
		ICursor *lR = NULL;
		TVERIFYRC(lQ->execute(&lR, NULL,0,~0u,0));
		int lResultCount = 0;
		IPIN *pInResults;
		if (isVerbose()) mLogger.out() << "List of PINs returned " << std::endl;
		while((pInResults=lR->next())!=NULL)
		{
			lResultCount++;
			//if (isVerbose()) MVTApp::output(*pInResults,mLogger.out());
			if (isVerbose()) mLogger.out() << std::hex << pInResults->getPID().pid << std::endl;
			
			const Value * refVal = pInResults->getValue(lPropIdRef); 
			if ( refVal!=NULL )
			{
				MvStoreEx::CollectionIterator lCollection(refVal);
				bool lBelongs = false;
				const Value *lValue;
				for(lValue = lCollection.getFirst(); lValue!=NULL; lValue = lCollection.getNext())
				{
					TVERIFY(lValue->type == VT_REFID);
					IPIN *lPIN = lSession->getPIN(lValue->id); TVERIFY(lPIN != NULL);
					const Value *lVal = lPIN->getValue(lPropIdVal); 
					MvStoreEx::CollectionIterator lValues(lVal);
					const Value *lVal1;
					for(lVal1 = lValues.getFirst(); lVal1!=NULL; lVal1 = lValues.getNext())
					{
						TVERIFY(lVal1->type == VT_INT);
						if(lVal1->i < threshold)
						{ lBelongs = true; break; }
					}
					lPIN->destroy();
					if(lBelongs) break;
				}
				TVERIFY(lBelongs && "Unexpected PIN returned");
			}
			else
			{
				TVERIFY(false && "Failed to fetch the collection");
			}

			pInResults->destroy();
		}

		mLogger.out() << " Total PINs returned in the result set " << std::dec << lResultCount << std::endl;
		TVERIFY(lResultCount == lCount);

		lR->destroy();
		lQ->destroy();

		lSession->terminate();
		MVTApp::stopStore();
	}
	else { TVERIFY(!"could not open store") ; }

	return lSuccess ? 0 : 1;
}
Пример #14
0
void wrenInitializeCore(WrenVM* vm)
{
  // Define the root Object class. This has to be done a little specially
  // because it has no superclass and an unusual metaclass (Class).
  vm->objectClass = defineSingleClass(vm, "Object");
  NATIVE(vm->objectClass, "== ", object_eqeq);
  NATIVE(vm->objectClass, "!= ", object_bangeq);
  NATIVE(vm->objectClass, "new", object_new);
  NATIVE(vm->objectClass, "toString", object_toString);
  NATIVE(vm->objectClass, "type", object_type);
  NATIVE(vm->objectClass, " instantiate", object_instantiate);

  // Now we can define Class, which is a subclass of Object, but Object's
  // metaclass.
  vm->classClass = defineSingleClass(vm, "Class");

  // Now that Object and Class are defined, we can wire them up to each other.
  wrenBindSuperclass(vm, vm->classClass, vm->objectClass);
  vm->objectClass->metaclass = vm->classClass;
  vm->classClass->metaclass = vm->classClass;

  // Define the methods specific to Class after wiring up its superclass to
  // prevent the inherited ones from overwriting them.
  NATIVE(vm->classClass, " instantiate", class_instantiate);
  NATIVE(vm->classClass, "name", class_name);

  // The core class diagram ends up looking like this, where single lines point
  // to a class's superclass, and double lines point to its metaclass:
  //
  //             __________        /====\
  //            /          \      //    \\
  //           v            \     v      \\
  //     .---------.   .--------------.  //
  //     | Object  |==>|    Class     |==/
  //     '---------'   '--------------'
  //          ^               ^
  //          |               |
  //     .---------.   .--------------.   \
  //     |  Base   |==>|  Base.type   |    |
  //     '---------'   '--------------'    |
  //          ^               ^            | Hypothetical example classes
  //          |               |            |
  //     .---------.   .--------------.    |
  //     | Derived |==>| Derived.type |    |
  //     '---------'   '--------------'    /

  // The rest of the classes can not be defined normally.
  vm->boolClass = defineClass(vm, "Bool");
  NATIVE(vm->boolClass, "toString", bool_toString);
  NATIVE(vm->boolClass, "!", bool_not);

  // TODO: Make fibers inherit Sequence and be iterable.
  vm->fiberClass = defineClass(vm, "Fiber");
  NATIVE(vm->fiberClass->metaclass, " instantiate", fiber_instantiate);
  NATIVE(vm->fiberClass->metaclass, "new ", fiber_new);
  NATIVE(vm->fiberClass->metaclass, "yield", fiber_yield);
  NATIVE(vm->fiberClass->metaclass, "yield ", fiber_yield1);
  NATIVE(vm->fiberClass, "call", fiber_call);
  NATIVE(vm->fiberClass, "call ", fiber_call1);
  NATIVE(vm->fiberClass, "isDone", fiber_isDone);
  NATIVE(vm->fiberClass, "run", fiber_run);
  NATIVE(vm->fiberClass, "run ", fiber_run1);

  vm->fnClass = defineClass(vm, "Fn");

  NATIVE(vm->fnClass->metaclass, " instantiate", fn_instantiate);
  NATIVE(vm->fnClass->metaclass, "new ", fn_new);

  NATIVE(vm->fnClass, "call", fn_call0);
  NATIVE(vm->fnClass, "call ", fn_call1);
  NATIVE(vm->fnClass, "call  ", fn_call2);
  NATIVE(vm->fnClass, "call   ", fn_call3);
  NATIVE(vm->fnClass, "call    ", fn_call4);
  NATIVE(vm->fnClass, "call     ", fn_call5);
  NATIVE(vm->fnClass, "call      ", fn_call6);
  NATIVE(vm->fnClass, "call       ", fn_call7);
  NATIVE(vm->fnClass, "call        ", fn_call8);
  NATIVE(vm->fnClass, "call         ", fn_call9);
  NATIVE(vm->fnClass, "call          ", fn_call10);
  NATIVE(vm->fnClass, "call           ", fn_call11);
  NATIVE(vm->fnClass, "call            ", fn_call12);
  NATIVE(vm->fnClass, "call             ", fn_call13);
  NATIVE(vm->fnClass, "call              ", fn_call14);
  NATIVE(vm->fnClass, "call               ", fn_call15);
  NATIVE(vm->fnClass, "call                ", fn_call16);
  NATIVE(vm->fnClass, "toString", fn_toString);

  vm->nullClass = defineClass(vm, "Null");
  NATIVE(vm->nullClass, "toString", null_toString);

  vm->numClass = defineClass(vm, "Num");
  NATIVE(vm->numClass, "abs", num_abs);
  NATIVE(vm->numClass, "ceil", num_ceil);
  NATIVE(vm->numClass, "cos", num_cos);
  NATIVE(vm->numClass, "floor", num_floor);
  NATIVE(vm->numClass, "isNan", num_isNan);
  NATIVE(vm->numClass, "sin", num_sin);
  NATIVE(vm->numClass, "sqrt", num_sqrt);
  NATIVE(vm->numClass, "toString", num_toString)
  NATIVE(vm->numClass, "-", num_negate);
  NATIVE(vm->numClass, "- ", num_minus);
  NATIVE(vm->numClass, "+ ", num_plus);
  NATIVE(vm->numClass, "* ", num_multiply);
  NATIVE(vm->numClass, "/ ", num_divide);
  NATIVE(vm->numClass, "% ", num_mod);
  NATIVE(vm->numClass, "< ", num_lt);
  NATIVE(vm->numClass, "> ", num_gt);
  NATIVE(vm->numClass, "<= ", num_lte);
  NATIVE(vm->numClass, ">= ", num_gte);
  NATIVE(vm->numClass, "~", num_bitwiseNot);
  NATIVE(vm->numClass, "& ", num_bitwiseAnd);
  NATIVE(vm->numClass, "| ", num_bitwiseOr);
  NATIVE(vm->numClass, ".. ", num_dotDot);
  NATIVE(vm->numClass, "... ", num_dotDotDot);

  vm->stringClass = defineClass(vm, "String");
  NATIVE(vm->stringClass, "contains ", string_contains);
  NATIVE(vm->stringClass, "count", string_count);
  NATIVE(vm->stringClass, "toString", string_toString)
  NATIVE(vm->stringClass, "+ ", string_plus);
  NATIVE(vm->stringClass, "== ", string_eqeq);
  NATIVE(vm->stringClass, "!= ", string_bangeq);
  NATIVE(vm->stringClass, "[ ]", string_subscript);

  wrenInterpret(vm, "Wren core library", libSource);

  vm->listClass = AS_CLASS(findGlobal(vm, "List"));
  NATIVE(vm->listClass->metaclass, " instantiate", list_instantiate);
  NATIVE(vm->listClass, "add ", list_add);
  NATIVE(vm->listClass, "clear", list_clear);
  NATIVE(vm->listClass, "count", list_count);
  NATIVE(vm->listClass, "insert  ", list_insert);
  NATIVE(vm->listClass, "iterate ", list_iterate);
  NATIVE(vm->listClass, "iteratorValue ", list_iteratorValue);
  NATIVE(vm->listClass, "removeAt ", list_removeAt);
  NATIVE(vm->listClass, "[ ]", list_subscript);
  NATIVE(vm->listClass, "[ ]=", list_subscriptSetter);

  vm->rangeClass = AS_CLASS(findGlobal(vm, "Range"));
  NATIVE(vm->rangeClass, "from", range_from);
  NATIVE(vm->rangeClass, "to", range_to);
  NATIVE(vm->rangeClass, "min", range_min);
  NATIVE(vm->rangeClass, "max", range_max);
  NATIVE(vm->rangeClass, "isInclusive", range_isInclusive);
  NATIVE(vm->rangeClass, "iterate ", range_iterate);
  NATIVE(vm->rangeClass, "iteratorValue ", range_iteratorValue);
  NATIVE(vm->rangeClass, "toString", range_toString);

  // These are defined just so that 0 and -0 are equal, which is specified by
  // IEEE 754 even though they have different bit representations.
  NATIVE(vm->numClass, "== ", num_eqeq);
  NATIVE(vm->numClass, "!= ", num_bangeq);
}