--- /dev/null
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace Tizen.NUI.Devel.Tests
+{
+ using tlog = Tizen.Log;
+
+ [TestFixture]
+ [Description("public/Window/GLWindow.cs")]
+ internal class PublicGLWindowTest
+ {
+ private const string tag = "NUITEST";
+
+ [SetUp]
+ public void Init()
+ {
+ tlog.Info(tag, "Init() is called!");
+ }
+
+ [TearDown]
+ public void Destroy()
+ {
+ tlog.Info(tag, "Destroy() is called!");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Create a GLWindow object.")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GLWindow C")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "CONSTR")]
+ [Property("COVPARAM", "")]
+ public void GLWindowConstructor()
+ {
+ tlog.Debug(tag, $"GLWindowConstructor START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindow a2 = new GLWindow();
+ GLWindow a3 = new GLWindow(GLWindow.getCPtr(a1).Handle, true);
+
+ a1.Destroy();
+ a2.Destroy();
+ a3.Destroy();
+ tlog.Debug(tag, $"GLWindowConstructor END (OK)");
+ Assert.Pass("GLWindowConstructor");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow WindowSize")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.WindowSize A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowWindowSize()
+ {
+ tlog.Debug(tag, $"GLWindowWindowSize START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ Size2D b1 = a1.WindowSize;
+ a1.WindowSize = b1;
+ a1.WindowSize = null;
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowWindowSize END (OK)");
+ Assert.Pass("GLWindowWindowSize");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow SetEglConfig")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.SetEglConfig M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowSetEglConfig()
+ {
+ tlog.Debug(tag, $"GLWindowSetEglConfig START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindow.GLESVersion b1 = new GLWindow.GLESVersion();
+ a1.SetEglConfig(true, true, 10, b1);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowSetEglConfig END (OK)");
+ Assert.Pass("GLWindowSetEglConfig");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Show")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Show M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowShow()
+ {
+ tlog.Debug(tag, $"GLWindowShow START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Show();
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowShow END (OK)");
+ Assert.Pass("GLWindowShow");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Hide")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Hide M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowHide()
+ {
+ tlog.Debug(tag, $"GLWindowHide START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Hide();
+
+ tlog.Debug(tag, $"GLWindowHide END (OK)");
+ Assert.Pass("GLWindowHide");
+ }
+
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Raise")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Raise M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowRaise()
+ {
+ tlog.Debug(tag, $"GLWindowRaise START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Raise();
+
+ tlog.Debug(tag, $"GLWindowRaise END (OK)");
+ Assert.Pass("GLWindowRaise");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Lower")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Lower M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowLower()
+ {
+ tlog.Debug(tag, $"GLWindowLower START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Lower();
+
+ tlog.Debug(tag, $"GLWindowLower END (OK)");
+ Assert.Pass("GLWindowLower");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Activate")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Activate M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowActivate()
+ {
+ tlog.Debug(tag, $"GLWindowActivate START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Activate();
+
+ tlog.Debug(tag, $"GLWindowActivate END (OK)");
+ Assert.Pass("GLWindowActivate");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow WindowPositionSize")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.WindowPositionSize A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowWindowPositionSize()
+ {
+ tlog.Debug(tag, $"GLWindowWindowPositionSize START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ Rectangle b1 = a1.WindowPositionSize;
+ a1.WindowPositionSize = b1;
+
+ tlog.Debug(tag, $"GLWindowWindowPositionSize END (OK)");
+ Assert.Pass("GLWindowWindowPositionSize");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GetSupportedAuxiliaryHintCount")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GetSupportedAuxiliaryHintCount M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowGetSupportedAuxiliaryHintCount()
+ {
+ tlog.Debug(tag, $"GLWindowGetSupportedAuxiliaryHintCount START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.GetSupportedAuxiliaryHintCount();
+
+ tlog.Debug(tag, $"GLWindowGetSupportedAuxiliaryHintCount END (OK)");
+ Assert.Pass("GLWindowGetSupportedAuxiliaryHintCount");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GetSupportedAuxiliaryHint")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GetSupportedAuxiliaryHint M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowGetSupportedAuxiliaryHint()
+ {
+ tlog.Debug(tag, $"GLWindowGetSupportedAuxiliaryHint START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.GetSupportedAuxiliaryHint(1);
+
+ tlog.Debug(tag, $"GLWindowGetSupportedAuxiliaryHint END (OK)");
+ Assert.Pass("GLWindowGetSupportedAuxiliaryHint");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow AddAuxiliaryHint")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.AddAuxiliaryHint M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowAddAuxiliaryHint()
+ {
+ tlog.Debug(tag, $"GLWindowAddAuxiliaryHint START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.AddAuxiliaryHint("myHint", "myValue");
+
+ tlog.Debug(tag, $"GLWindowAddAuxiliaryHint END (OK)");
+ Assert.Pass("GLWindowAddAuxiliaryHint");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow RemoveAuxiliaryHint")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.RemoveAuxiliaryHint M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowRemoveAuxiliaryHint()
+ {
+ tlog.Debug(tag, $"GLWindowRemoveAuxiliaryHint START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ uint pos = a1.AddAuxiliaryHint("myHint", "myValue");
+ a1.RemoveAuxiliaryHint(pos);
+
+ tlog.Debug(tag, $"GLWindowRemoveAuxiliaryHint END (OK)");
+ Assert.Pass("GLWindowRemoveAuxiliaryHint");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow SetAuxiliaryHintValue")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.SetAuxiliaryHintValue M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowSetAuxiliaryHintValue()
+ {
+ tlog.Debug(tag, $"GLWindowSetAuxiliaryHintValue START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ uint pos = a1.AddAuxiliaryHint("myHint", "myValue");
+ a1.SetAuxiliaryHintValue(pos, "myValue");
+
+
+ tlog.Debug(tag, $"GLWindowSetAuxiliaryHintValue END (OK)");
+ Assert.Pass("GLWindowSetAuxiliaryHintValue");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GetAuxiliaryHintValue")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GetAuxiliaryHintValue M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowGetAuxiliaryHintValue()
+ {
+ tlog.Debug(tag, $"GLWindowGetAuxiliaryHintValue START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ uint pos = a1.AddAuxiliaryHint("myHint", "myValue");
+ a1.GetAuxiliaryHintValue(pos);
+
+
+ tlog.Debug(tag, $"GLWindowGetAuxiliaryHintValue END (OK)");
+ Assert.Pass("GLWindowGetAuxiliaryHintValue");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GetAuxiliaryHintId")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GetAuxiliaryHintId M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowGetAuxiliaryHintId()
+ {
+ tlog.Debug(tag, $"GLWindowGetAuxiliaryHintId START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ uint pos = a1.AddAuxiliaryHint("myHint", "myValue");
+ a1.GetAuxiliaryHintId("myHint");
+
+ tlog.Debug(tag, $"GLWindowGetAuxiliaryHintId END (OK)");
+ Assert.Pass("GLWindowGetAuxiliaryHintId");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow SetInputRegion")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.SetInputRegion M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowSetInputRegion()
+ {
+ tlog.Debug(tag, $"GLWindowSetInputRegion START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.SetInputRegion(rectangle);
+ tlog.Debug(tag, $"GLWindowGetAuxiliaryHintId END (OK)");
+ Assert.Pass("GLWindowGetAuxiliaryHintId");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow SetOpaqueState")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.SetOpaqueState M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowSetOpaqueState()
+ {
+ tlog.Debug(tag, $"GLWindowSetOpaqueState START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.SetOpaqueState(true);
+ tlog.Debug(tag, $"GLWindowSetOpaqueState END (OK)");
+ Assert.Pass("GLWindowSetOpaqueState");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow IsOpaqueState")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.IsOpaqueState M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowIsOpaqueState()
+ {
+ tlog.Debug(tag, $"GLWindowIsOpaqueState START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.IsOpaqueState();
+ tlog.Debug(tag, $"GLWindowIsOpaqueState END (OK)");
+ Assert.Pass("GLWindowIsOpaqueState");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow SetPreferredOrientation")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.SetPreferredOrientation M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowSetPreferredOrientation()
+ {
+ tlog.Debug(tag, $"GLWindowSetPreferredOrientation START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindow.GLWindowOrientation o1 = new GLWindow.GLWindowOrientation();
+ a1.SetPreferredOrientation(o1);
+ tlog.Debug(tag, $"GLWindowSetPreferredOrientation END (OK)");
+ Assert.Pass("GLWindowSetPreferredOrientation");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GetCurrentOrientation")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GetCurrentOrientation M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowGetCurrentOrientation()
+ {
+ tlog.Debug(tag, $"GLWindowGetCurrentOrientation START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+
+ a1.GetCurrentOrientation();
+ tlog.Debug(tag, $"GLWindowGetCurrentOrientation END (OK)");
+ Assert.Pass("GLWindowGetCurrentOrientation");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow SetAvailableOrientations")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.SetAvailableOrientations M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowSetAvailableOrientations()
+ {
+ tlog.Debug(tag, $"GLWindowSetAvailableOrientations START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindow.GLWindowOrientation o1 = new GLWindow.GLWindowOrientation();
+ List<GLWindow.GLWindowOrientation> l1 = new List<GLWindow.GLWindowOrientation>
+ {
+ o1
+ };
+
+ a1.SetAvailableOrientations(l1);
+
+ tlog.Debug(tag, $"GLWindowSetAvailableOrientations END (OK)");
+ Assert.Pass("GLWindowSetAvailableOrientations");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow RenderOnce")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.RenderOnce M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowRenderOnce()
+ {
+ tlog.Debug(tag, $"GLWindowRenderOnce START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.RenderOnce();
+ tlog.Debug(tag, $"GLWindowRenderOnce END (OK)");
+ Assert.Pass("GLWindowRenderOnce");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow RegisterGlCallback")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.RegisterGlCallback M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowRegisterGlCallback()
+ {
+ tlog.Debug(tag, $"GLWindowRegisterGlCallback START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+
+ a1.RegisterGlCallback(b1, c1, d1);
+ tlog.Debug(tag, $"GLWindowRegisterGlCallback END (OK)");
+ Assert.Pass("GLWindowRegisterGlCallback");
+ }
+
+ public void b1() { }
+ public int c1() { return 0; }
+ public void d1() { }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Destroy")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Destroy M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowDestroy()
+ {
+ tlog.Debug(tag, $"GLWindowDestroy START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowDestroy END (OK)");
+ Assert.Pass("GLWindowDestroy");
+ }
+ }
+}
+
--- /dev/null
+using NUnit.Framework;
+
+namespace Tizen.NUI.Devel.Tests
+{
+ using tlog = Tizen.Log;
+
+ [TestFixture]
+ [Description("public/Window/GLWindowEvent")]
+ internal class PublicGLWindowEventTest
+ {
+ private const string tag = "NUITEST";
+
+ [SetUp]
+ public void Init()
+ {
+ tlog.Info(tag, "Init() is called!");
+ }
+
+ [TearDown]
+ public void Destroy()
+ {
+ tlog.Info(tag, "Destroy() is called!");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow FocusChanged")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.FocusChanged A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowFocusChanged()
+ {
+ tlog.Debug(tag, $"GLWindowFocusChanged START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.FocusChanged += A1_FocusChanged;
+ a1.FocusChanged -= A1_FocusChanged;
+
+ GLWindow.FocusChangedEventArgs e1 = new GLWindow.FocusChangedEventArgs();
+ A1_FocusChanged(null, e1);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowFocusChanged END (OK)");
+ Assert.Pass("GLWindowFocusChanged");
+ }
+
+ private void A1_FocusChanged(object sender, GLWindow.FocusChangedEventArgs e)
+ {
+ bool c1 = e.FocusGained;
+ e.FocusGained = c1;
+
+ return;
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow TouchEvent")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.TouchEvent A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowTouchEvent()
+ {
+ tlog.Debug(tag, $"GLWindowTouchEvent START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.TouchEvent += A1_TouchEvent;
+ a1.TouchEvent -= A1_TouchEvent;
+
+ GLWindow.TouchEventArgs e1 = new GLWindow.TouchEventArgs();
+ A1_TouchEvent(null, e1);
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowTouchEvent END (OK)");
+ Assert.Pass("GLWindowTouchEvent");
+ }
+
+ private void A1_TouchEvent(object sender, GLWindow.TouchEventArgs e)
+ {
+ Touch t1 = e.Touch;
+ e.Touch = t1;
+
+ return;
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow KeyEvent")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.KeyEvent A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowKeyEvent()
+ {
+ tlog.Debug(tag, $"GLWindowKeyEvent START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.KeyEvent += A1_KeyEvent;
+ a1.KeyEvent -= A1_KeyEvent;
+
+ GLWindow.KeyEventArgs e1 = new GLWindow.KeyEventArgs();
+ A1_KeyEvent(null, e1);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowKeyEvent END (OK)");
+ Assert.Pass("GLWindowKeyEvent");
+ }
+
+ private void A1_KeyEvent(object sender, GLWindow.KeyEventArgs e)
+ {
+ Key k1 = e.Key;
+ e.Key = k1;
+ return;
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow Resized")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.Resized A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowResized()
+ {
+ tlog.Debug(tag, $"GLWindowResized START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.Resized += A1_Resized;
+ a1.Resized -= A1_Resized;
+
+ GLWindow.ResizedEventArgs e1 = new GLWindow.ResizedEventArgs();
+ A1_Resized(null, e1);
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowResized END (OK)");
+ Assert.Pass("GLWindowResized");
+ }
+
+ private void A1_Resized(object sender, GLWindow.ResizedEventArgs e)
+ {
+ Size2D s1 = e.WindowSize;
+ e.WindowSize = s1;
+ return;
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow FocusChangedSignal")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.FocusChangedSignal M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowFocusChangedSignal()
+ {
+ tlog.Debug(tag, $"GLWindowFocusChangedSignal START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.FocusChangedSignal();
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowFocusChangedSignal END (OK)");
+ Assert.Pass("GLWindowFocusChangedSignal");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow KeyEventSignal")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.KeyEventSignal M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowKeyEventSignal()
+ {
+ tlog.Debug(tag, $"GLWindowKeyEventSignal START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.KeyEventSignal();
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowKeyEventSignal END (OK)");
+ Assert.Pass("GLWindowKeyEventSignal");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow TouchSignal")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.TouchSignal M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowTouchSignal()
+ {
+ tlog.Debug(tag, $"GLWindowTouchSignal START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.TouchSignal();
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowTouchSignal END (OK)");
+ Assert.Pass("GLWindowTouchSignal");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GLWindowResizedSignal")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.GLWindowResizedSignal M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowGLWindowResizedSignal()
+ {
+ tlog.Debug(tag, $"GLWindowGLWindowResizedSignal START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.GLWindowResizedSignal();
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowGLWindowResizedSignal END (OK)");
+ Assert.Pass("GLWindowGLWindowResizedSignal");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GLWindowDisconnectNativeSignals")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.DisconnectNativeSignals M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowDisconnectNativeSignals()
+ {
+ tlog.Debug(tag, $"GLWindowDisconnectNativeSignals START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.DisconnectNativeSignals();
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowDisconnectNativeSignals END (OK)");
+ Assert.Pass("GLWindowDisconnectNativeSignals");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GLWindowVisibilityChanged")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.VisibilityChanged A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void GLWindowVisibilityChanged()
+ {
+ tlog.Debug(tag, $"GLWindowVisibilityChanged START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.VisibilityChanged += A1_VisibilityChanged;
+ a1.VisibilityChanged -= A1_VisibilityChanged;
+
+ GLWindow.VisibilityChangedEventArgs e1 = new GLWindow.VisibilityChangedEventArgs();
+ A1_VisibilityChanged(null, e1);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowVisibilityChanged END (OK)");
+ Assert.Pass("GLWindowVisibilityChanged");
+ }
+
+ private void A1_VisibilityChanged(object sender, GLWindow.VisibilityChangedEventArgs e)
+ {
+ bool b1 = e.Visibility;
+ e.Visibility = b1;
+
+ return;
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindow GLWindowVisibiltyChangedSignalEmit")]
+ [Property("SPEC", "Tizen.NUI.GLWindow.VisibiltyChangedSignalEmit M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowVisibiltyChangedSignalEmit()
+ {
+ tlog.Debug(tag, $"GLWindowVisibiltyChangedSignalEmit START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ a1.VisibiltyChangedSignalEmit(true);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowVisibiltyChangedSignalEmit END (OK)");
+ Assert.Pass("GLWindowVisibiltyChangedSignalEmit");
+ }
+ }
+}
+
--- /dev/null
+using NUnit.Framework;
+
+namespace Tizen.NUI.Devel.Tests
+{
+ using tlog = Tizen.Log;
+
+ [TestFixture]
+ [Description("public/Window/GLWindowVisibilityChangedEvent")]
+ internal class PublicGLWindowVisibilityChangedEventTest
+ {
+ private const string tag = "NUITEST";
+
+ [SetUp]
+ public void Init()
+ {
+ tlog.Info(tag, "Init() is called!");
+ }
+
+ [TearDown]
+ public void Destroy()
+ {
+ tlog.Info(tag, "Destroy() is called!");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Create a GLWindowVisibilityChangedEvent object.")]
+ [Property("SPEC", "Tizen.NUI.GLWindowVisibilityChangedEvent.GLWindowVisibilityChangedEvent C")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "CONSTR")]
+ [Property("COVPARAM", "")]
+ public void GLWindowVisibilityChangedEventConstructor()
+ {
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventConstructor START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindowVisibilityChangedEvent b1 = new GLWindowVisibilityChangedEvent(a1);
+
+ b1.Dispose();
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventConstructor END (OK)");
+ Assert.Pass("GLWindowVisibilityChangedEventConstructor");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindowVisibilityChangedEvent Empty")]
+ [Property("SPEC", "Tizen.NUI.GLWindowVisibilityChangedEvent.Empty M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowVisibilityChangedEventEmpty()
+ {
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventEmpty START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindowVisibilityChangedEvent b1 = new GLWindowVisibilityChangedEvent(a1);
+ b1.Empty();
+
+ b1.Dispose();
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventEmpty END (OK)");
+ Assert.Pass("GLWindowVisibilityChangedEventEmpty");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindowVisibilityChangedEvent GetConnectionCount")]
+ [Property("SPEC", "Tizen.NUI.GLWindowVisibilityChangedEvent.GetConnectionCount M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowVisibilityChangedEventGetConnectionCount()
+ {
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventGetConnectionCount START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindowVisibilityChangedEvent b1 = new GLWindowVisibilityChangedEvent(a1);
+ b1.GetConnectionCount();
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventGetConnectionCount END (OK)");
+ Assert.Pass("GLWindowVisibilityChangedEventGetConnectionCount");
+ }
+
+ //[Test]
+ //[Category("P1")]
+ //[Description("GLWindowVisibilityChangedEvent Connect")]
+ //[Property("SPEC", "Tizen.NUI.GLWindowVisibilityChangedEvent.Connect M")]
+ //[Property("SPEC_URL", "-")]
+ //[Property("CRITERIA", "MR")]
+ //public void GLWindowVisibilityChangedEventConnect()
+ //{
+ // tlog.Debug(tag, $"GLWindowVisibilityChangedEventConnect START");
+ // string name = "myGLWindow";
+ // Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ // GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ // GLWindowVisibilityChangedEvent b1 = new GLWindowVisibilityChangedEvent(a1);
+
+ // Delegate s1 = new Delegate;
+ // b1.Connect(s1);
+
+ // a1.Destroy();
+ // tlog.Debug(tag, $"GLWindowVisibilityChangedEventConnect END (OK)");
+ // Assert.Pass("GLWindowVisibilityChangedEventConnect");
+ //}
+
+ [Test]
+ [Category("P1")]
+ [Description("GLWindowVisibilityChangedEvent Emit")]
+ [Property("SPEC", "Tizen.NUI.GLWindowVisibilityChangedEvent.Emit M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void GLWindowVisibilityChangedEventEmit()
+ {
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventEmit START");
+ string name = "myGLWindow";
+ Rectangle rectangle = new Rectangle(20, 20, 100, 100);
+ GLWindow a1 = new GLWindow(name, rectangle, true);
+
+ GLWindowVisibilityChangedEvent b1 = new GLWindowVisibilityChangedEvent(a1);
+ b1.Emit(a1, true);
+
+ a1.Destroy();
+ tlog.Debug(tag, $"GLWindowVisibilityChangedEventEmit END (OK)");
+ Assert.Pass("GLWindowVisibilityChangedEventEmit");
+ }
+ }
+}
+
--- /dev/null
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using static Tizen.NUI.Window;
+
+namespace Tizen.NUI.Devel.Tests
+{
+ using tlog = Tizen.Log;
+
+ [TestFixture]
+ [Description("public/Window/Window")]
+ internal class PublicWindowTest
+ {
+ private const string tag = "NUITEST";
+ private static Window myWin;
+ [SetUp]
+ public void Init()
+ {
+ Rectangle r1 = new Rectangle(0, 0, 20, 20);
+ myWin = new Window(r1);
+ tlog.Info(tag, "Init() is called!");
+ }
+
+ [TearDown]
+ public void Destroy()
+ {
+ if (myWin != null)
+ {
+ myWin.Dispose();
+ myWin = null;
+ }
+ tlog.Info(tag, "Destroy() is called!");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window WindowPositionSize")]
+ [Property("SPEC", "Tizen.NUI.Window.WindowPositionSize A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void WindowWindowPositionSize()
+ {
+ tlog.Debug(tag, $"WindowWindowPositionSize START");
+ try
+ {
+ Rectangle r1 = myWin.WindowPositionSize;
+ myWin.WindowPositionSize = r1;
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowWindowPositionSize END (OK)");
+ Assert.Pass("WindowWindowPositionSize");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window DEFAULT_BACKGROUND_COLOR")]
+ [Property("SPEC", "Tizen.NUI.Window.DEFAULT_BACKGROUND_COLOR A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void WindowDEFAULT_BACKGROUND_COLOR()
+ {
+ tlog.Debug(tag, $"WindowDEFAULT_BACKGROUND_COLOR START");
+ try
+ {
+ Vector4 v1 = Window.DEFAULT_BACKGROUND_COLOR;
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowDEFAULT_BACKGROUND_COLOR END (OK)");
+ Assert.Pass("WindowDEFAULT_BACKGROUND_COLOR");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window DEBUG_BACKGROUND_COLOR")]
+ [Property("SPEC", "Tizen.NUI.Window.DEBUG_BACKGROUND_COLOR A")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "PRW")]
+ public void WindowDEBUG_BACKGROUND_COLOR()
+ {
+ tlog.Debug(tag, $"WindowDEBUG_BACKGROUND_COLOR START");
+ try
+ {
+ Vector4 v1 = Window.DEBUG_BACKGROUND_COLOR;
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowDEBUG_BACKGROUND_COLOR END (OK)");
+ Assert.Pass("WindowDEBUG_BACKGROUND_COLOR");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window GetLayer")]
+ [Property("SPEC", "Tizen.NUI.Window.GetLayer M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowGetLayer()
+ {
+ tlog.Debug(tag, $"WindowGetLayer START");
+ try
+ {
+ myWin.GetLayer(65535);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowGetLayer END (OK)");
+ Assert.Pass("WindowGetLayer");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window Destroy")]
+ [Property("SPEC", "Tizen.NUI.Window.Destroy M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowDestroy()
+ {
+ tlog.Debug(tag, $"WindowDestroy START");
+ try
+ {
+ Rectangle r2 = new Rectangle(0, 0, 20, 20);
+ Window w1 = new Window(r2);
+
+ w1.Destroy();
+ w1 = null;
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowDestroy END (OK)");
+ Assert.Pass("WindowDestroy");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window GetCurrentOrientation")]
+ [Property("SPEC", "Tizen.NUI.Window.GetCurrentOrientation M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowGetCurrentOrientation()
+ {
+ tlog.Debug(tag, $"WindowGetCurrentOrientation START");
+ try
+ {
+ myWin.GetCurrentOrientation();
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowGetCurrentOrientation END (OK)");
+ Assert.Pass("WindowGetCurrentOrientation");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window SetAvailableOrientations")]
+ [Property("SPEC", "Tizen.NUI.Window.SetAvailableOrientations M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowSetAvailableOrientations()
+ {
+ tlog.Debug(tag, $"WindowSetAvailableOrientations START");
+ try
+ {
+ List<Window.WindowOrientation> l1 = new List<Window.WindowOrientation>();
+ Window.WindowOrientation o1 = new Window.WindowOrientation();
+
+ l1.Add(o1);
+ myWin.SetAvailableOrientations(l1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowSetAvailableOrientations END (OK)");
+ Assert.Pass("WindowSetAvailableOrientations");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window GetNativeId")]
+ [Property("SPEC", "Tizen.NUI.Window.GetNativeId M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowGetNativeId()
+ {
+ tlog.Debug(tag, $"WindowGetNativeId START");
+ try
+ {
+ myWin.GetNativeId();
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowGetNativeId END (OK)");
+ Assert.Pass("WindowGetNativeId");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window GetNativeHandle")]
+ [Property("SPEC", "Tizen.NUI.Window.GetNativeHandle M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowGetNativeHandle()
+ {
+ tlog.Debug(tag, $"WindowGetNativeHandle START");
+ try
+ {
+ myWin.GetNativeHandle();
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowGetNativeHandle END (OK)");
+ Assert.Pass("WindowGetNativeHandle");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window Add")]
+ [Property("SPEC", "Tizen.NUI.Window.Add M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowAdd()
+ {
+ tlog.Debug(tag, $"WindowAdd START");
+ try
+ {
+ Layer layer = null;
+ myWin.Add(layer);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowAdd END (OK)");
+ Assert.Pass("WindowAdd");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window Remove")]
+ [Property("SPEC", "Tizen.NUI.Window.Remove M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowRemove()
+ {
+ tlog.Debug(tag, $"WindowRemove START");
+ try
+ {
+ Layer layer = null;
+ myWin.Remove(layer);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowRemove END (OK)");
+ Assert.Pass("WindowRemove");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window GetRenderTaskList")]
+ [Property("SPEC", "Tizen.NUI.Window.GetRenderTaskList M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowGetRenderTaskList()
+ {
+ tlog.Debug(tag, $"WindowGetRenderTaskList START");
+ try
+ {
+ myWin.GetRenderTaskList();
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowGetRenderTaskList END (OK)");
+ Assert.Pass("WindowGetRenderTaskList");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window GetObjectRegistry")]
+ [Property("SPEC", "Tizen.NUI.Window.GetObjectRegistry M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowGetObjectRegistry()
+ {
+ tlog.Debug(tag, $"WindowGetObjectRegistry START");
+ try
+ {
+ myWin.GetObjectRegistry();
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowGetObjectRegistry END (OK)");
+ Assert.Pass("WindowGetObjectRegistry");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window SetWindowSize")]
+ [Property("SPEC", "Tizen.NUI.Window.SetWindowSize M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowSetWindowSize()
+ {
+ tlog.Debug(tag, $"WindowSetWindowSize START");
+ try
+ {
+ Size2D s1 = null;
+ myWin.SetWindowSize(s1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowSetWindowSize END (OK)");
+ Assert.Pass("WindowSetWindowSize");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window SetPosition")]
+ [Property("SPEC", "Tizen.NUI.Window.SetPosition M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowSetPosition()
+ {
+ tlog.Debug(tag, $"WindowSetPosition START");
+ try
+ {
+ Position2D p1 = null;
+ myWin.SetPosition(p1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowSetPosition END (OK)");
+ Assert.Pass("WindowSetPosition");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window SetPositionSize")]
+ [Property("SPEC", "Tizen.NUI.Window.SetPositionSize M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowSetPositionSize()
+ {
+ tlog.Debug(tag, $"WindowSetPositionSize START");
+ try
+ {
+ Rectangle r1 = new Rectangle(0, 0, 20, 20);
+ myWin.SetPositionSize(r1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowSetPositionSize END (OK)");
+ Assert.Pass("WindowSetPositionSize");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window AddFrameUpdateCallback")]
+ [Property("SPEC", "Tizen.NUI.Window.AddFrameUpdateCallback M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowAddFrameUpdateCallback()
+ {
+ tlog.Debug(tag, $"WindowAddFrameUpdateCallback START");
+ try
+ {
+ FrameUpdateCallbackInterface f1 = new FrameUpdateCallbackInterface();
+ myWin.AddFrameUpdateCallback(f1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowAddFrameUpdateCallback END (OK)");
+ Assert.Pass("WindowAddFrameUpdateCallback");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window RemoveFrameUpdateCallback")]
+ [Property("SPEC", "Tizen.NUI.Window.RemoveFrameUpdateCallback M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowRemoveFrameUpdateCallback()
+ {
+ tlog.Debug(tag, $"WindowRemoveFrameUpdateCallback START");
+ try
+ {
+ FrameUpdateCallbackInterface f1 = new FrameUpdateCallbackInterface();
+ myWin.RemoveFrameUpdateCallback(f1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowRemoveFrameUpdateCallback END (OK)");
+ Assert.Pass("WindowRemoveFrameUpdateCallback");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window AddFrameRenderedCallback")]
+ [Property("SPEC", "Tizen.NUI.Window.AddFrameRenderedCallback M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowAddFrameRenderedCallback()
+ {
+ tlog.Debug(tag, $"WindowAddFrameRenderedCallback START");
+ try
+ {
+ FrameCallbackType f1 = null;
+ myWin.AddFrameRenderedCallback(f1, 1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowAddFrameRenderedCallback END (OK)");
+ Assert.Pass("WindowAddFrameRenderedCallback");
+ }
+
+ [Test]
+ [Category("P1")]
+ [Description("Window AddFramePresentedCallback")]
+ [Property("SPEC", "Tizen.NUI.Window.AddFramePresentedCallback M")]
+ [Property("SPEC_URL", "-")]
+ [Property("CRITERIA", "MR")]
+ public void WindowAddFramePresentedCallback()
+ {
+ tlog.Debug(tag, $"WindowAddFramePresentedCallback START");
+ try
+ {
+ FrameCallbackType f1 = null;
+ myWin.AddFramePresentedCallback(f1, 1);
+ }
+ catch (Exception e)
+ {
+ Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
+
+ Assert.Fail("Caught Exception" + e.ToString());
+ }
+ tlog.Debug(tag, $"WindowAddFramePresentedCallback END (OK)");
+ Assert.Pass("WindowAddFramePresentedCallback");
+ }
+ }
+}
\ No newline at end of file
projects / platform / core / csapi / tizenfx.git / commitdiff