private void CreateSideWalls()
{
// Create the root for the side walls
EmptyObject wallRoot = new EmptyObject();
GameObjectManager.Active.Attach(wallRoot);
var collisonPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.Wall_vs_Alien);
collisonPair.SetFirstCollisonRoot(wallRoot);
collisonPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.Wall_vs_Player);
collisonPair.SetFirstCollisonRoot(wallRoot);
collisonPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.Wall_vs_UFO);
collisonPair.SetFirstCollisonRoot(wallRoot);
// Create the left wall
Wall left = new Wall(this.VerticalWallWidth, this.VerticalWallHeight);
left.Collider.Color = this.CollisonColor;
left.SetPosition(this.LeftWallX, this.VerticalWallY);
wallRoot.AddChild(left);
GameObjectManager.Active.Attach(left);
// Create the right wall
Wall right = new Wall(this.VerticalWallWidth, this.VerticalWallHeight);
right.Collider.Color = this.CollisonColor;
right.SetPosition(this.RightWallX, this.VerticalWallY);
wallRoot.AddChild(right);
GameObjectManager.Active.Attach(right);
// Recalculate collider of root
wallRoot.RecalculateCollider();
}
public void CanConvertEmptyObjectToJson()
{
var empty = new EmptyObject();
var json = empty.ToJson();
Assert.Equal("{}", json);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
var dummyPersonWithNoJobs = Person.CreateObject();
dummyPersonWithNoJobs.Jobs = new Job[0];
EmptyObject.BusinessObject = (IBusinessObject)dummyPersonWithNoJobs;
EmptyObject.LoadValues(false);
var view1 = new BocListView {
ItemID = "ViewCmd1", Title = "View 1"
};
var view2 = new BocListView {
ItemID = "ViewCmd2", Title = "View 2"
};
JobList_Normal.AvailableViews.AddRange(view1, view2);
JobList_Normal.SelectedView = view2;
JobList_Normal.MenuItemClick += MenuItemClickHandler;
JobList_Normal.SortingOrderChanged += SortingOrderChangedHandler;
JobList_Normal.EditableRowChangesSaved += EditableRowChangedSavedHandler;
JobList_Normal.EditableRowChangesCanceled += EditableRowChangesCanceledHandler;
JobList_Normal.ListItemCommandClick += ListItemCommandClickHandler;
JobList_Normal.CustomCellClick += CustomCellClickHandler;
}
public override async Task <IActionResult> StoreVideo(IFormFile file)
{
try
{
if (file == null)
{
var response400 = new EmptyObject()
{
Success = false, Message = "The uploaded file is null."
};
return(StatusCode(400, response400));
}
var response = new StoreVideoResponse
{
Message = "Video stored successfully", Success = true
};
await _mediaStorageService.StoreVideo(file);
return(StatusCode(200, response));
}
catch (Exception e)
{
var response500 = new EmptyObject()
{
Success = false, Message = e.ToString()
};
return(StatusCode(500, response500));
}
}
public void LiteObjectBase_ShouldDoNothing_WithoutDefaultAttributes()
{
EmptyObject testObject = null;
var exception = Record.Exception(() => testObject = new EmptyObject());
exception.Should().BeNull();
testObject.Should().NotBeNull();
}
public override IActionResult RemoveTools(RemoveToolsRequest removeToolsRequest)
{
var response = new EmptyObject {
Success = true
};
_pipelineService.RemoveTools(removeToolsRequest);
return(StatusCode(200, response));
}
public override IActionResult CreatePipeline(CreatePipelineRequest createPipelineRequest)
{
_pipelineService.CreatePipeline(createPipelineRequest);
var response = new EmptyObject {
Success = true
};
return(StatusCode(200, response));
}
protected void EmptyWorld()
{
for (int i = 0; i < Size.GetLength(0); i++)
{
for (int j = 0; j < Size.GetLength(1); j++)
{
Size[i, j] = new EmptyObject();
}
}
}
public void TestDeepCloneableDeepCopyWithEmptyObject()
{
// Arrange
var emptyObject = new EmptyObject();
// Act
var deepCopy = emptyObject.DeepCopy();
// Assert
Assert.NotNull(deepCopy);
Assert.False(Object.ReferenceEquals(emptyObject, deepCopy));
}
public void TestEmptyObjectOnline()
{
using (var ignite = Ignition.Start(TestUtils.GetTestConfiguration()))
{
var cache = ignite.CreateCache <int, EmptyObject>("c");
cache[1] = new EmptyObject();
var res = cache[1];
Assert.IsNotNull(res);
}
}
public override IActionResult DeleteVideo(DeleteVideoRequest deleteVideoRequest)
{
var response = new EmptyObject {
Success = true
};
if (_mediaStorageService.DeleteVideo(deleteVideoRequest).Result)
{
return(StatusCode(200, response));
}
response.Success = false;
response.Message = "Video could not be deleted.";
return(StatusCode(400, response));
}
public override IActionResult DeletePipeline(DeletePipelineRequest deletePipelineRequest)
{
var response = new EmptyObject()
{
Success = true
};
if (_pipelineService.DeletePipeline(deletePipelineRequest).Result)
{
return(StatusCode(200, response));
}
response.Success = false;
response.Message = "Pipeline could not be deleted";
return(StatusCode(400, response));
}
public override IActionResult AddTools(AddToolsRequest addToolsRequest)
{
var response = new EmptyObject {
Success = true
};
if (_pipelineService.AddTools(addToolsRequest))
{
return(StatusCode(200, response));
}
response.Success = false;
response.Message = "Addition of tools to pipeline failed";
return(StatusCode(400, response));
}
public void GetLiteObjectType_Should_ReturnValue()
{
EmptyObject testObject = null;
Type liteObjectType = null;
var exception = Record.Exception(() =>
{
testObject = new EmptyObject();
liteObjectType = (new LiteObjectService()).GetLiteObjectType(testObject);
});
exception.Should().BeNull();
testObject.Should().NotBeNull();
liteObjectType.Should().NotBeNull();
}
public void RunBench()
{
EmptyObject obj;
for (int size = INITSIZE; size < MAXSIZE; size *= 2)
{
for (int i = 0; i < size; i++)
{
for (int j = 0; j < OBJECTS_COUNT; j++)
{
obj = new EmptyObject();
}
}
}
System.GC.Collect();
}
public override IActionResult GetVideo(GetVideoRequest getVideoRequest)
{
var response = _mediaStorageService.GetVideo(getVideoRequest).Result;
if (response != null)
{
return(StatusCode(200, response));
}
var fail = new EmptyObject
{
Success = false,
Message = "No video exists associated with video id: " + getVideoRequest.Id
};
return(StatusCode(400, fail));
}
public void TestJsonObjectToJsonWithEmptyObject()
{
// Arrange
// Act
var toJsonSerializerSettings = new JsonSerializerSettings
{
Formatting = Formatting.Indented
};
var json = EmptyObject.ToJson(toJsonSerializerSettings);
this.Output.WriteLine(json);
// Assert
Assert.NotNull(json);
Assert.False(String.IsNullOrEmpty(json));
var jObject = JObject.Parse(json);
AssertEmpty(EmptyObject, jObject);
}
public void ShowGameOverScreen()
{
if (gameoverSprite == null)
{
gameoverSprite = new EmptyObject();
gameoverSprite.AddComponent(new SpriteRenderer(Game.Content.Load <Texture2D>(@"Sprites\GameOver")));
Game.Components.Add(gameoverSprite);
// exit button
_2DRenderer exitButtonRenderer = new SpriteRenderer(Game.Content.Load <Texture2D>(@"Sprites\MainMenuButton"));
exitButtonRenderer.AddChildRenderer(new TextRenderer("Exit"));
exitButtonRenderer.position = new Vector2(0.45f, 0.65f);
exitButtonRenderer.size = new Vector2(0.1f, 0.1f);
HUD exitButton = new HUD(exitButtonRenderer);
exitButton.onClick = ExitButtonClick;
Game.Components.Add(exitButton);
inputManager.toggleCursor(true);
}
}
/// <summary>
///
/// </summary>
/// <exception cref="Dowding.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="emptyObject"></param>
/// <returns>Task of ApiResponse (AuthToken)</returns>
public async System.Threading.Tasks.Task <ApiResponse <AuthToken> > AuthenticationRefreshPostAsyncWithHttpInfo(EmptyObject emptyObject)
{
// verify the required parameter 'emptyObject' is set
if (emptyObject == null)
{
throw new ApiException(400, "Missing required parameter 'emptyObject' when calling AuthenticationApi->AuthenticationRefreshPost");
}
var localVarPath = "/authentication/refresh";
var localVarPathParams = new Dictionary <String, String>();
var localVarQueryParams = new Dictionary <String, String>();
var localVarHeaderParams = new Dictionary <String, String>(Configuration.DefaultHeader);
var localVarFormParams = new Dictionary <String, String>();
var localVarFileParams = new Dictionary <String, FileParameter>();
Object localVarPostBody = null;
// to determine the Content-Type header
String[] localVarHttpContentTypes = new String[] {
"application/json"
};
String localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);
// to determine the Accept header
String[] localVarHttpHeaderAccepts = new String[] {
"application/json"
};
String localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
if (localVarHttpHeaderAccept != null)
{
localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
}
// set "format" to json by default
// e.g. /pet/{petId}.{format} becomes /pet/{petId}.json
localVarPathParams.Add("format", "json");
if (emptyObject != null && emptyObject.GetType() != typeof(byte[]))
{
localVarPostBody = Configuration.ApiClient.Serialize(emptyObject); // http body (model) parameter
}
else
{
localVarPostBody = emptyObject; // byte array
}
// authentication (bearer) required
if (!String.IsNullOrEmpty(Configuration.GetApiKeyWithPrefix("Authorization")))
{
localVarHeaderParams["Authorization"] = Configuration.GetApiKeyWithPrefix("Authorization");
}
// make the HTTP request
IRestResponse localVarResponse = (IRestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
Method.POST, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams,
localVarPathParams, localVarHttpContentType);
int localVarStatusCode = (int)localVarResponse.StatusCode;
if (ExceptionFactory != null)
{
Exception exception = ExceptionFactory("AuthenticationRefreshPost", localVarResponse);
if (exception != null)
{
throw exception;
}
}
return(new ApiResponse <AuthToken>(localVarStatusCode,
localVarResponse.Headers.ToDictionary(x => x.Name, x => x.Value.ToString()),
(AuthToken)Configuration.ApiClient.Deserialize(localVarResponse, typeof(AuthToken))));
}
/// <summary>
/// Setup the collision pairs for the player
/// </summary>
private void SetupCollisionHierarchy()
{
CollisionPairEvaluator collisionPair = null;
// Create the collision root for player laser
EmptyObject playerLaserRoot = new EmptyObject();
playerLaserRoot.SetPosition(-10f, -10f); // Throw to a bottom corner
GameObjectManager.Active.Attach(playerLaserRoot);
// Set the root of this collision
this.sceneRef.SetPlayerLaserRoot(playerLaserRoot);
// Find all collision pairs the laser is a part of
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.PlayerLaser_vs_WallTop);
collisionPair.SetFirstCollisonRoot(playerLaserRoot);
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.PlayerLaser_vs_Alien);
collisionPair.SetFirstCollisonRoot(playerLaserRoot);
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.PlayerLaser_vs_Shield);
collisionPair.SetFirstCollisonRoot(playerLaserRoot);
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.PlayerLaser_vs_UFO);
collisionPair.SetFirstCollisonRoot(playerLaserRoot);
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.PlayerLaser_vs_AlienLaser);
collisionPair.SetFirstCollisonRoot(playerLaserRoot);
//////////////////////////////////////////////
// Create the collision root for the player
EmptyObject playerRoot = new EmptyObject();
playerRoot.SetPosition(this.InitX, this.InitY);
GameObjectManager.Active.Attach(playerRoot);
// Set the root of this collision
this.sceneRef.SetPlayerRoot(playerRoot);
// Find all the collision pairs the player is a part of
// Wall vs Player
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.Wall_vs_Player);
collisionPair.SetSecondCollisonRoot(playerRoot);
// Player vs Alien
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.Player_vs_Alien);
collisionPair.SetFirstCollisonRoot(playerRoot);
// Player vs AlienLaser
collisionPair = CollisonPairManager.Active.Find(CollisionPairEvaluator.Name.Player_vs_AlienLaser);
collisionPair.SetFirstCollisonRoot(playerRoot);
// Don't need the reference anymore
this.sceneRef = null;
}
public ComplexObject()
{
obj = new EmptyObject();
}
public static Boolean EvaluateQueue(
DynContext DynLanContext)
{
ExpressionState expState = DynLanContext.CurrentExpressionState;
ExpressionContext expContext = DynLanContext.CurrentExpressionContext;
// policzenie nastepnego parametru
if (expState.AreParametersCalculating)
{
expState.ParameterIndex++;
if (expState.ParameterIndex < expState.ParameterTokens.Count)
{
Boolean result = false;
ExpressionToken parameterToken = expState.ParameterTokens[expState.ParameterIndex];
if (parameterToken.TokenType == TokenType.VARIABLE)
{
result = ObjectValueGetter.EvaluateValue(
parameterToken.TokenName,
DynLanContext);
}
else if (parameterToken.TokenType == TokenType.VALUE)
{
ExpressionValue operationValue = StringHelper.
GetValueFromText(parameterToken.TokenChars);
Object value = (
operationValue == null ? null : operationValue.Value);
expState.Parameters.Add(value);
}
else
{
throw new DynLanIncorrectExpressionFormatException();
}
return(result);
}
}
// czy zakończyć i zapisać wynik
if (expState.TokenIndex >= expState.Expression.Tokens.Count)
{
Object finResult = null;
if (expState.ValueStack.Count > 0)
{
finResult = MyCollectionsExtenders.Pop(expState.ValueStack);
}
expState.ValueStack.Clear();
expState.Finished = true;
expState.Result = InternalTypeConverter.ToOuter(finResult);
MyCollectionsExtenders.Pop(expContext.Stack);
if (expContext.Current != null)
{
expContext.Current.PushValue(InternalTypeConverter.ToOuter(finResult));
return(false);
}
else
{
expContext.Result = InternalTypeConverter.ToOuter(finResult);
expContext.IsFinished = true;
return(true);
}
}
Boolean isFirstToken = expState.TokenIndex == 0;
ExpressionToken token = expState.
Expression.
Tokens[expState.TokenIndex];
ExpressionTokens sequence = new ExpressionTokens(
new TokenizerQueue().
GetNextTokensOnSameLevel(expState.Expression.Tokens, expState.TokenIndex));
Int32 originalSequenceCount = sequence.Count;
sequence.RemoveBrackets();
// wykonanie następnej operacji
if (token.TokenType == TokenType.BRACKET_BEGIN)
{
IList <ExpressionToken> prevSequenceTokens = new TokenizerQueue().
GetPrevTokensOnSameLevel(expState.Expression.Tokens, expState.TokenIndex - 1);
ExpressionTokens prev_sequence = prevSequenceTokens == null ?
null : new ExpressionTokens(prevSequenceTokens);
// jeśli poprzedni operator to @
if (
prev_sequence != null && prev_sequence.Count == 1 &&
OnpOnpTokenHelper.IsFunctionOperatorToken(prev_sequence[0]))
{
Boolean result = false;
if (sequence.Count == 0 || expState.AreParametersCalculated)
{
Object obj = expState.ValueStack.Count == 1 ?
new EmptyObject() :
MyCollectionsExtenders.Peek(expState.ValueStack, 1);
Object methodObject = MyCollectionsExtenders.
Peek(expState.ValueStack, 0);
result = EvaluatorForMethods.EvaluateMethod(
obj,
methodObject,
expState.Parameters,
DynLanContext);
expState.CleanParametersState();
expState.TokenIndex += originalSequenceCount;
}
else
{
expState.ParameterTokens = GetParameterTokens(sequence);
expState.ParameterIndex = -1;
expState.Parameters = new List <Object>();
result = false;
}
return(result);
}
// jeśli poprzedni operator to .
else if (
prev_sequence != null && prev_sequence.Count == 1 &&
OnpOnpTokenHelper.IsPropertyOperatorToken(prev_sequence[0]))
{
throw new DynLanIncorrectExpressionFormatException();
}
// jeśli brak poprzedniego operatora
else if (
prev_sequence == null &&
sequence.Count == 1)
{
Boolean result = false;
if (sequence[0].TokenType == TokenType.VARIABLE)
{
result = ObjectValueGetter.EvaluateValue(
sequence[0].TokenName,
DynLanContext);
}
else if (sequence[0].TokenType == TokenType.VALUE)
{
ExpressionValue operationValue = StringHelper.
GetValueFromText(sequence[0].TokenChars);
Object value = (
operationValue == null ? null : operationValue.Value);
expState.PushValue(value);
}
else
{
throw new DynLanIncorrectExpressionFormatException();
}
expState.TokenIndex += originalSequenceCount; // -1;
return(result);
}
else
{
throw new DynLanInvalidExpressionException("Incorrect expression " + expState.Expression.Tokens.JoinToString(expState.TokenIndex) + "!");
}
}
else if (token.TokenType == TokenType.VALUE)
{
ExpressionValue operationValue = StringHelper.
GetValueFromText(token.TokenChars);
Object value = (
operationValue == null ? null : operationValue.Value);
if (isFirstToken)
{
expState.PushValue(value);
}
else
{
Object prevValue = MyCollectionsExtenders.Peek(expState.ValueStack);
prevValue = InternalTypeConverter.
ToOuter(prevValue);
Object method = ObjectValueGetter.GetValueFromObject(
prevValue,
UniConvert.ToString(value));
expState.PushValue(method);
}
expState.TokenIndex += originalSequenceCount; // -1
}
else if (token.TokenType == TokenType.PROPERTY_NAME)
{
if (isFirstToken)
{
throw new DynLanIncorrectExpressionFormatException();
}
else
{
Object prevValue = MyCollectionsExtenders.Peek(expState.ValueStack);
prevValue = InternalTypeConverter.
ToOuter(prevValue);
Object value = ObjectValueGetter.GetValueFromObject(
prevValue,
token.TokenName);
expState.PushValue(value);
}
expState.TokenIndex += originalSequenceCount; // -1
}
else if (token.TokenType == TokenType.VARIABLE)
{
Boolean result = false;
ExpressionToken next_token = expState.TokenIndex + 1 < expState.Expression.Tokens.Count ?
expState.Expression.Tokens[expState.TokenIndex + 1] :
null;
Object prevValue = null;
if (isFirstToken)
{
prevValue = new EmptyObject();
/*result = ObjectValueGetter.EvaluateValueOrMethod(
* new EMPTY_OBJECT(),
* sequence[0].TokenName,
* -1,
* DynLanContext);*/
}
else
{
prevValue = (
expState.ValueStack.Count == 0 ?
null :
MyCollectionsExtenders.Peek(expState.ValueStack));
}
prevValue = InternalTypeConverter.
ToOuter(prevValue);
Int32 paramCount = -1;
// jeśli następny operator to operator wołania funkcji @ to pobieramy z niego liczbę parametrów dla funkcji
if (OnpOnpTokenHelper.IsFunctionOperatorToken(next_token) &&
next_token.TokenData != null &&
next_token.TokenData.FunctionParametersCount != null)
{
paramCount = next_token.TokenData.FunctionParametersCount.Value;
}
else
{
paramCount = -1;
}
result = ObjectValueGetter.EvaluateValueOrMethod(
prevValue,
sequence[0].TokenName,
paramCount,
DynLanContext);
if (MyCollectionsExtenders.Peek(DynLanContext.CurrentExpressionState.ValueStack) == null)
{
ExpressionToken next_next_token = expState.TokenIndex + 2 < expState.Expression.Tokens.Count ?
expState.Expression.Tokens[expState.TokenIndex + 2] :
null;
if (next_token.TokenType == TokenType.OPERATOR &&
OnpOnpTokenHelper.IsPropertyOperatorToken(next_token) &&
next_next_token != null)
{
}
else
{
next_next_token = null;
}
if (paramCount < 0)
{
if (next_next_token != null)
{
ExpressionToken next_next_next_next_next_token = expState.TokenIndex + 5 < expState.Expression.Tokens.Count ?
expState.Expression.Tokens[expState.TokenIndex + 5] :
null;
if (next_next_token.TokenName == "__EXT_SET" && next_next_next_next_next_token != null)
{
throw new DynLanMethodNotFoundException("Cannot find property " + next_next_next_next_next_token.TokenName + " in undefined object '" + sequence[0].TokenName + "'");
}
else
{
throw new DynLanMethodNotFoundException("Cannot call method '" + next_next_token.TokenName + "' in undefined object '" + sequence[0].TokenName + "'");
}
}
else
{
throw new DynLanMethodNotFoundException("Undefined object '" + sequence[0].TokenName + "'");
}
}
else
{
throw new DynLanMethodNotFoundException("Undefined method '" + sequence[0].TokenName + "' " + (prevValue == null ? "in undefined object" : ("in object of type " + prevValue.GetType().Name)));
}
}
expState.TokenIndex += originalSequenceCount; // -1
return(result);
}
else if (token.TokenType == TokenType.OPERATOR)
{
if (!OnpOnpTokenHelper.IsFunctionOperatorToken(token) &&
!OnpOnpTokenHelper.IsPropertyOperatorToken(token))
{
throw new DynLanIncorrectExpressionFormatException();
}
expState.TokenIndex += originalSequenceCount; // -1
}
if (MyCollectionsExtenders.Peek(expState.ValueStack) == null)
{
return(false);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <exception cref="Dowding.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="emptyObject"></param>
/// <returns>AuthToken</returns>
public AuthToken AuthenticationRefreshPost(EmptyObject emptyObject)
{
ApiResponse <AuthToken> localVarResponse = AuthenticationRefreshPostWithHttpInfo(emptyObject);
return(localVarResponse.Data);
}
/// <summary>
///
/// </summary>
/// <exception cref="Dowding.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="emptyObject"></param>
/// <returns>Task of AuthToken</returns>
public async System.Threading.Tasks.Task <AuthToken> AuthenticationRefreshPostAsync(EmptyObject emptyObject)
{
ApiResponse <AuthToken> localVarResponse = await AuthenticationRefreshPostAsyncWithHttpInfo(emptyObject);
return(localVarResponse.Data);
}
static void CSharpObjects()
{
Console.Write("\nC# object exposure ");
Engine engine = CreateEngine();
// test the empty interface
{
NI.CreateObject(engine.ctx, IntPtr.Zero, IObjectBase._sgsNullObjectInterface);
engine.Stat(Stat.XDumpStack);
engine.Pop(1);
}
// init & disown object
IObject obj = new EmptyObject(engine);
engine.Push(obj);
AssertN(obj._sgsObject, IntPtr.Zero);
engine.Stat(Stat.XDumpStack); // should have refcount = 2 (one for IObject and one for stack)
Variable si0 = engine.StackItem(0);
Assert(engine.Call <string>("typeof", si0), "EmptyObject");
si0.Release(); // for accurate refcount (otherwise this reference is retained for an unknown amount of time)
obj.DisownClassObject(); // free IObject reference
engine.Stat(Stat.XDumpStack); // should have refcount = 1 (stack) and name = <nullObject>
Assert(engine.Call <string>("typeof", engine.StackItem(0)), "<nullObject>");
engine.Pop(1);
// test metamethods
IObject obj1 = new FullObject1(engine);
Variable obj1var = engine.Var(obj1);
Assert(engine.Call <bool>("tobool", obj1), false); // test "convert"(tobool)/ConvertToBool
Assert(engine.Call <string>("tostring", obj1), "[Full_Object_1]"); // test "convert"(tostring)/ConvertToString
Assert(engine.Call <string>("dumpvar", obj1), "[this is a FULL OBJECT]\n"); // test "dump"/OnDump
Assert(obj1var.SetProp("prop1", engine.Var(15)), true); // test "setindex"(isprop=true)
Assert(obj1var.SetProp("prop2", engine.Var(16)), true);
Assert(obj1var.SetProp("prop3", engine.Var(17)), true);
AssertVar(obj1var.GetProp("prop1"), engine.Var(15)); // test "getindex"(isprop=true)
AssertVar(obj1var.GetProp("prop2"), engine.Var(16.0f));
AssertVar(obj1var.GetProp("prop3"), engine.Var("17"));
AssertVar(obj1var.GetProp("invprop1"), null); // - HideProperty()
AssertVar(obj1var.GetProp("invprop2"), engine.Var(234)); // - HideProperty()
AssertVar(obj1var.GetProp("invprop3"), null); // - HideProperty()
// test method wrapper
DNMethod dnm1 = new DNMethod(engine, typeof(FullObject1).GetMethod("TestMethod"));
Variable dnm1var = engine.Var(dnm1);
Assert(engine.ThisCall <string>(dnm1var, obj1var, "test"), "17|test");
dnm1.DisownClassObject();
// test static method wrapper
DNMethod dnm2 = new DNMethod(engine, typeof(FullObject1).GetMethod("StaticTestMethod"));
Variable dnm2var = engine.Var(dnm2);
Assert(engine.Call <string>(dnm2var, "sTest"), "PFX:sTest");
dnm2.DisownClassObject();
// test static method dictionary
Assert(engine.Call <string>("tostring", IObjectBase.CreateStaticDict(engine, typeof(FullObject1))),
"{_useProp3=DNMethod,StaticTestMethod=DNMethod,TestMethod=DNMethod,TestMsgMethod=DNMethod}");
// test static (meta-)object
Variable movar = engine._GetMetaObject(typeof(FullObject1)).GetVariable();
AssertVar(movar, obj1var.GetMetaObj());
Assert(movar.GetProp("_useProp3").ConvertToString(), "SGScript.DNMethod(APITest.APITest+FullObject1._useProp3)");
Assert(movar.GetProp("pfxstr").GetString(), "PFX:");
// test instance meta object lookup
Assert(obj1var.GetProp("_useProp3").ConvertToString(), "SGScript.DNMethod(APITest.APITest+FullObject1._useProp3)");
Assert(obj1var.GetProp("pfxstr").GetString(), "PFX:");
Assert(obj1var.GetMetaObj().SetProp("pfxstr", engine.Var("[PFX]:")), true);
Assert(obj1var.GetMetaObj().GetProp("pfxstr").GetString(), "[PFX]:");
Assert(obj1var.GetProp("pfxstr").GetString(), "[PFX]:");
// register type
engine.SetGlobal("FullObject1", engine._GetMetaObject(typeof(FullObject1)).GetVariable());
// test extension method
engine.Exec("function FullObject1.customMethod( txt ){ return this.pfxstr .. txt; }");
AssertN(obj1var.GetMetaObj().GetProp("customMethod"), null);
Assert(engine.ThisCall <string>("customMethod", obj1var, "cmTest"), "[PFX]:cmTest");
// test method messaging
engine.ThisCall <Nothing>("TestMsgMethod", obj1var, 121, 754);
DestroyEngine(engine);
FullObject1.pfxstr = "PFX:"; // restore
}
