}
END_TEST;
}
+
+int UtcDaliActorLowerBelowNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.LowerBelow(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRaiseAboveNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.RaiseAbove(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRaiseToTopNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.RaiseToTop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorAddRendererNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Renderer arg1;
+ instance.AddRenderer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorTouchSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.TouchSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorTranslateByNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ instance.TranslateBy(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorFindChildByIdNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ unsigned int arg1 = 0u;
+ instance.FindChildById(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetRendererAtNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ unsigned int arg1 = 0u;
+ instance.GetRendererAt(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorHoveredSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.HoveredSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorLowerToBottomNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.LowerToBottom();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorOnSceneSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.OnSceneSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorOffSceneSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.OffSceneSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRemoveRendererNegative01(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ unsigned int arg1 = 0u;
+ instance.RemoveRenderer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRemoveRendererNegative02(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Renderer arg1;
+ instance.RemoveRenderer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorFindChildByNameNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ std::string arg1;
+ instance.FindChildByName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorSetResizePolicyNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::ResizePolicy::Type arg1 = ResizePolicy::USE_NATURAL_SIZE;
+ Dali::Dimension::Type arg2 = Dimension::ALL_DIMENSIONS;
+ instance.SetResizePolicy(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorOnRelayoutSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.OnRelayoutSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorWheelEventSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.WheelEventSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetHeightForWidthNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ float arg1 = 0.0f;
+ instance.GetHeightForWidth(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetWidthForHeightNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ float arg1 = 0.0f;
+ instance.GetWidthForHeight(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorLayoutDirectionChangedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.LayoutDirectionChangedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorAddNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.Add(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorLowerNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.Lower();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRaiseNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.Raise();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRemoveNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.Remove(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorScaleByNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ instance.ScaleBy(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetLayerNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetLayer();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRotateByNegative01(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Quaternion arg1;
+ instance.RotateBy(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorRotateByNegative02(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Radian arg1;
+ Dali::Vector3 arg2;
+ instance.RotateBy(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorUnparentNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.Unparent();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetChildAtNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ unsigned int arg1 = 0u;
+ instance.GetChildAt(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetChildCountNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetChildCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetTargetSizeNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetTargetSize();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorScreenToLocalNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ float arg1 = 0.0f;
+ float arg2 = 0.0f;
+ float arg3 = 0.0f;
+ float arg4 = 0.0f;
+ instance.ScreenToLocal(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetNaturalSizeNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetNaturalSize();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetRelayoutSizeNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Dimension::Type arg1 = Dimension::HEIGHT;
+ instance.GetRelayoutSize(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetResizePolicyNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ Dali::Dimension::Type arg1 = Dimension::ALL_DIMENSIONS;
+ instance.GetResizePolicy(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetRendererCountNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetRendererCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliActorGetParentNegative(void)
+{
+ TestApplication application;
+ Dali::Actor instance;
+ try
+ {
+ instance.GetParent();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliAnimationSetLoopingNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetLooping(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetDurationNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetDuration(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetLoopCountNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetLoopCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetEndActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Animation::EndAction arg1(Animation::Bake);
+ instance.SetEndAction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopCountNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ int arg1(0);
+ instance.SetLoopCount(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetPlayRangeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetPlayRange(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative01(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ instance.AnimateBetween(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::Animation::Interpolation arg3(Animation::Linear);
+ instance.AnimateBetween(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateBetween(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::TimePeriod arg3(1.0f);
+ Dali::Animation::Interpolation arg4(Animation::Linear);
+ instance.AnimateBetween(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative05(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ instance.AnimateBetween(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative06(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::Animation::Interpolation arg4(Animation::Linear);
+ instance.AnimateBetween(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative07(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateBetween(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative08(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ Dali::Animation::Interpolation arg5(Animation::Linear);
+ instance.AnimateBetween(arg1,arg2,arg3,arg4,arg5);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationFinishedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.FinishedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetCurrentLoopNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetCurrentLoop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopingModeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Animation::LoopingMode arg1(Animation::RESTART);
+ instance.SetLoopingMode(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetSpeedFactorNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetSpeedFactor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetCurrentProgressNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetCurrentProgress();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetCurrentProgressNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetCurrentProgress(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetDisconnectActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Animation::EndAction arg1(Animation::Bake);
+ instance.SetDisconnectAction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetDefaultAlphaFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::AlphaFunction arg1;
+ instance.SetDefaultAlphaFunction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationHideNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ float arg2(0.0f);
+ instance.Hide(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Play();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationShowNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ float arg2(0.0f);
+ instance.Show(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationStopNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Stop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationClearNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Clear();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPauseNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Pause();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative01(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ instance.Animate(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.Animate(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ Dali::AlphaFunction arg4;
+ instance.Animate(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ Dali::AlphaFunction arg4;
+ Dali::TimePeriod arg5(1.0f);
+ instance.Animate(arg1,arg2,arg3,arg4,arg5);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayFromNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.PlayFrom(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative01(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ instance.AnimateBy(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateBy(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ instance.AnimateBy(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateBy(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative01(void)
+{
+ TestApplication application;
+ Dali::Actor actor;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ instance.AnimateTo(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateTo(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ instance.AnimateTo(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateTo(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayAfterNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.PlayAfter(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetDurationNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetDuration();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetEndActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetEndAction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetPlayRangeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetPlayRange();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetLoopingModeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetLoopingMode();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetSpeedFactorNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetSpeedFactor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetDisconnectActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetDisconnectAction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetDefaultAlphaFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetDefaultAlphaFunction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetStateNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetState();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationIsLoopingNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.IsLooping();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliKeyFramesAddNegative01(void)
+{
+ TestApplication application;
+ Dali::KeyFrames instance;
+ try
+ {
+ float arg1(0.0f);
+ Dali::Property::Value arg2;
+ instance.Add(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliKeyFramesAddNegative02(void)
+{
+ TestApplication application;
+ Dali::KeyFrames instance;
+ try
+ {
+ float arg1(0.0f);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ instance.Add(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliKeyFramesGetTypeNegative(void)
+{
+ TestApplication application;
+ Dali::KeyFrames instance;
+ try
+ {
+ instance.GetType();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliBaseHandleDoActionNegative(void)
+{
+ TestApplication application;
+ Dali::BaseHandle instance;
+ try
+ {
+ std::string arg1;
+ Dali::Property::Map arg2;
+ instance.DoAction(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliBaseHandleGetTypeInfoNegative(void)
+{
+ TestApplication application;
+ Dali::BaseHandle instance;
+ try
+ {
+ Dali::TypeInfo arg1;
+ instance.GetTypeInfo(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliBaseHandleGetTypeNameNegative(void)
+{
+ TestApplication application;
+ Dali::BaseHandle instance;
+ try
+ {
+ instance.GetTypeName();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliCameraActorGetAspectRatioNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetAspectRatio();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetFieldOfViewNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetFieldOfView();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetInvertYAxisNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetInvertYAxis();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetAspectRatioNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetAspectRatio(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetFieldOfViewNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetFieldOfView(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetInvertYAxisNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetInvertYAxis(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetProjectionModeNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ Dali::Camera::ProjectionMode arg1(Camera::PERSPECTIVE_PROJECTION);
+ instance.SetProjectionMode(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetTargetPositionNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ instance.SetTargetPosition(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetFarClippingPlaneNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetFarClippingPlane();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetFarClippingPlaneNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetFarClippingPlane(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetNearClippingPlaneNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetNearClippingPlane();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetNearClippingPlaneNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetNearClippingPlane(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetPerspectiveProjectionNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetPerspectiveProjection(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetOrthographicProjectionNegative01(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ float arg1(0.0f);
+ float arg2(0.0f);
+ float arg3(0.0f);
+ float arg4(0.0f);
+ float arg5(0.0f);
+ float arg6(0.0f);
+ instance.SetOrthographicProjection(arg1,arg2,arg3,arg4,arg5,arg6);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetOrthographicProjectionNegative02(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetOrthographicProjection(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorSetTypeNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ Dali::Camera::Type arg1(Camera::FREE_LOOK);
+ instance.SetType(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetProjectionModeNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetProjectionMode();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetTargetPositionNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetTargetPosition();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliCameraActorGetTypeNegative(void)
+{
+ TestApplication application;
+ Dali::CameraActor instance;
+ try
+ {
+ instance.GetType();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliLinearConstrainerApplyNegative(void)
+{
+ TestApplication application;
+ Dali::LinearConstrainer instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Dali::Actor::Property::POSITION);
+ Dali::Property arg2(actor, Dali::Actor::Property::POSITION);
+ Dali::Vector2 arg3;
+ Dali::Vector2 arg4;
+ instance.Apply(arg1,arg2,arg3,arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLinearConstrainerRemoveNegative(void)
+{
+ TestApplication application;
+ Dali::LinearConstrainer instance;
+ try
+ {
+ Dali::Handle arg1;
+ instance.Remove(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
}
///////////////////////////////////////////////////////////////////////////////
+
+int UtcDaliConstraintGetTargetObjectNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ instance.GetTargetObject();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintSetRemoveActionNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ Dali::Constraint::RemoveAction arg1(Constraint::Bake);
+ instance.SetRemoveAction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintGetTargetPropertyNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ instance.GetTargetProperty();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintApplyNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ instance.Apply();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintCloneNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ Dali::Handle arg1;
+ instance.Clone(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintRemoveNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ instance.Remove();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintSetTagNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ unsigned int arg1(0u);
+ instance.SetTag(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintGetRemoveActionNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ instance.GetRemoveAction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliConstraintGetTagNegative(void)
+{
+ TestApplication application;
+ Dali::Constraint instance;
+ try
+ {
+ instance.GetTag();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliFrameBufferGetColorTextureNegative(void)
+{
+ TestApplication application;
+ Dali::FrameBuffer instance;
+ try
+ {
+ instance.GetColorTexture();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliFrameBufferAttachColorTextureNegative01(void)
+{
+ TestApplication application;
+ Dali::FrameBuffer instance;
+ try
+ {
+ Dali::Texture arg1 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 400u, 400u);
+ instance.AttachColorTexture(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliFrameBufferAttachColorTextureNegative02(void)
+{
+ TestApplication application;
+ Dali::FrameBuffer instance;
+ try
+ {
+ Dali::Texture arg1 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 400u, 400u);
+ unsigned int arg2(0u);
+ unsigned int arg3(0u);
+ instance.AttachColorTexture(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliGeometrySetIndexBufferNegative(void)
+{
+ TestApplication application;
+ Dali::Geometry instance;
+ try
+ {
+ unsigned short* arg1(nullptr);
+ unsigned long arg2(0u);
+ instance.SetIndexBuffer(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliGeometryAddVertexBufferNegative(void)
+{
+ TestApplication application;
+ Dali::Geometry instance;
+ try
+ {
+ Dali::PropertyBuffer arg1;
+ instance.AddVertexBuffer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliGeometryRemoveVertexBufferNegative(void)
+{
+ TestApplication application;
+ Dali::Geometry instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.RemoveVertexBuffer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliGeometrySetTypeNegative(void)
+{
+ TestApplication application;
+ Dali::Geometry instance;
+ try
+ {
+ Dali::Geometry::Type arg1(Geometry::POINTS);
+ instance.SetType(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliGeometryGetNumberOfVertexBuffersNegative(void)
+{
+ TestApplication application;
+ Dali::Geometry instance;
+ try
+ {
+ instance.GetNumberOfVertexBuffers();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliGeometryGetTypeNegative(void)
+{
+ TestApplication application;
+ Dali::Geometry instance;
+ try
+ {
+ instance.GetType();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliHandleSetPropertyNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ Dali::Property::Value arg2;
+ instance.SetProperty(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleRegisterPropertyNegative01(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ std::string arg1;
+ Dali::Property::Value arg2;
+ instance.RegisterProperty(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleRegisterPropertyNegative02(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ std::string arg1;
+ Dali::Property::Value arg2;
+ Dali::Property::AccessMode arg3(Property::READ_ONLY);
+ instance.RegisterProperty(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleRemoveConstraintsNegative01(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ unsigned int arg1(0u);
+ instance.RemoveConstraints(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleRemoveConstraintsNegative02(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ instance.RemoveConstraints();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleAddPropertyNotificationNegative01(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ int arg2(0);
+ Dali::PropertyCondition arg3;
+ instance.AddPropertyNotification(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleAddPropertyNotificationNegative02(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ Dali::PropertyCondition arg2;
+ instance.AddPropertyNotification(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleRemovePropertyNotificationNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ Dali::PropertyNotification arg1;
+ instance.RemovePropertyNotification(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleRemovePropertyNotificationsNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ instance.RemovePropertyNotifications();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetPropertyNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.GetProperty(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetPropertyNameNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.GetPropertyName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetPropertyTypeNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.GetPropertyType(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetPropertyCountNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ instance.GetPropertyCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetPropertyIndexNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ std::string arg1;
+ instance.GetPropertyIndex(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetCurrentPropertyNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.GetCurrentProperty(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleGetPropertyIndicesNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ Dali::Vector<int> arg1;
+ instance.GetPropertyIndices(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleIsPropertyWritableNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.IsPropertyWritable(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleIsPropertyAnimatableNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.IsPropertyAnimatable(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleIsPropertyAConstraintInputNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ int arg1(0);
+ instance.IsPropertyAConstraintInput(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliHandleSupportsNegative(void)
+{
+ TestApplication application;
+ Dali::Handle instance;
+ try
+ {
+ Dali::Handle::Capability arg1(Handle::DYNAMIC_PROPERTIES);
+ instance.Supports(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliLayerLowerBelowNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ Dali::Layer arg1;
+ instance.LowerBelow(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerRaiseAboveNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ Dali::Layer arg1;
+ instance.RaiseAbove(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerRaiseToTopNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ instance.RaiseToTop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerLowerToBottomNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ instance.LowerToBottom();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerSetSortFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ Layer::SortFunctionType function = nullptr;
+ instance.SetSortFunction(function);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerLowerNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ instance.Lower();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerRaiseNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ instance.Raise();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerMoveAboveNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ Dali::Layer arg1;
+ instance.MoveAbove(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliLayerMoveBelowNegative(void)
+{
+ TestApplication application;
+ Dali::Layer instance;
+ try
+ {
+ Dali::Layer arg1;
+ instance.MoveBelow(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
DALI_TEST_CHECK( test.mSignalVerified );
END_TEST;
}
+
+int UtcDaliObjectRegistryObjectCreatedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::ObjectRegistry instance;
+ try
+ {
+ instance.ObjectCreatedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliObjectRegistryObjectDestroyedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::ObjectRegistry instance;
+ try
+ {
+ instance.ObjectDestroyedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliPathAddControlPointNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ instance.AddControlPoint(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPathGetControlPointNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetControlPoint(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPathGenerateControlPointsNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.GenerateControlPoints(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPathAddPointNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ instance.AddPoint(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPathGetPointNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetPoint(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPathGetPointCountNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ instance.GetPointCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPathSampleNegative(void)
+{
+ TestApplication application;
+ Dali::Path instance;
+ try
+ {
+ float arg1(0.0f);
+ Dali::Vector3 arg2;
+ Dali::Vector3 arg3;
+ instance.Sample(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliPixelDataGetPixelFormatNegative(void)
+{
+ TestApplication application;
+ Dali::PixelData instance;
+ try
+ {
+ instance.GetPixelFormat();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPixelDataGetWidthNegative(void)
+{
+ TestApplication application;
+ Dali::PixelData instance;
+ try
+ {
+ instance.GetWidth();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPixelDataGetHeightNegative(void)
+{
+ TestApplication application;
+ Dali::PixelData instance;
+ try
+ {
+ instance.GetHeight();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliPropertyBufferSetDataNegative(void)
+{
+ TestApplication application;
+ Dali::PropertyBuffer instance;
+ try
+ {
+ void* arg1(nullptr);
+ unsigned long arg2(0u);
+ instance.SetData(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPropertyBufferGetSizeNegative(void)
+{
+ TestApplication application;
+ Dali::PropertyBuffer instance;
+ try
+ {
+ instance.GetSize();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliPropertyConditionGetArgumentNegative(void)
+{
+ TestApplication application;
+ Dali::PropertyCondition instance;
+ instance.Reset();
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetArgument(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliPropertyConditionGetArgumentCountNegative(void)
+{
+ TestApplication application;
+ Dali::PropertyCondition instance;
+ instance.Reset();
+ try
+ {
+ instance.GetArgumentCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliRenderTaskSetCullModeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetCullMode(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetViewportNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Rect<int> arg1;
+ instance.SetViewport(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetExclusiveNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetExclusive(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetClearColorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector4 arg1;
+ instance.SetClearColor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskFinishedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.FinishedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetCameraActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::CameraActor arg1;
+ instance.SetCameraActor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetFrameBufferNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::FrameBuffer arg1;
+ instance.SetFrameBuffer(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetRefreshRateNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ unsigned int arg1(0u);
+ instance.SetRefreshRate(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetSourceActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.SetSourceActor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetClearEnabledNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetClearEnabled(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetInputEnabledNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetInputEnabled(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetViewportSizeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetViewportSize(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetViewportPositionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetViewportPosition(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetScreenToFrameBufferFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ RenderTask::ScreenToFrameBufferFunction arg1(nullptr);
+ instance.SetScreenToFrameBufferFunction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskSetScreenToFrameBufferMappingActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Actor arg1;
+ instance.SetScreenToFrameBufferMappingActor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetCullModeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCullMode();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetViewportNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetViewport();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskIsExclusiveNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.IsExclusive();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetClearColorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetClearColor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetCameraActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCameraActor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetFrameBufferNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetFrameBuffer();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetRefreshRateNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetRefreshRate();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetSourceActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetSourceActor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetClearEnabledNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetClearEnabled();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetInputEnabledNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetInputEnabled();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskViewportToLocalNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Actor arg1(Actor::New());
+ float arg2(0.0f);
+ float arg3(0.0f);
+ float arg4(0.0f);
+ float arg5(0.0f);
+ instance.ViewportToLocal(arg1,arg2,arg3,arg4,arg5);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskWorldToViewportNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ Dali::Vector3 arg1;
+ float arg2(0.0f);
+ float arg3(0.0f);
+ instance.WorldToViewport(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetCurrentViewportSizeNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCurrentViewportSize();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetCurrentViewportPositionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetCurrentViewportPosition();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetScreenToFrameBufferFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetScreenToFrameBufferFunction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTask instance;
+ try
+ {
+ instance.GetScreenToFrameBufferMappingActor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
DALI_TEST_CHECK( taskList.GetTask( 0u ) == newTask );
END_TEST;
}
+
+int UtcDaliRenderTaskListCreateTaskNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTaskList instance;
+ try
+ {
+ instance.CreateTask();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskListRemoveTaskNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTaskList instance;
+ try
+ {
+ Dali::RenderTask arg1(application.GetScene().GetRenderTaskList().GetTask(0u));
+ instance.RemoveTask(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskListGetTaskCountNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTaskList instance;
+ try
+ {
+ instance.GetTaskCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRenderTaskListGetTaskNegative(void)
+{
+ TestApplication application;
+ Dali::RenderTaskList instance;
+ try
+ {
+ unsigned int arg1(0u);
+ instance.GetTask(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 3, TEST_LOCATION);
END_TEST;
-}
\ No newline at end of file
+}
+int UtcDaliRendererSetGeometryNegative(void)
+{
+ TestApplication application;
+ Dali::Renderer instance;
+ try
+ {
+ Dali::Geometry arg1;
+ instance.SetGeometry(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRendererSetTexturesNegative(void)
+{
+ TestApplication application;
+ Dali::Renderer instance;
+ try
+ {
+ Dali::TextureSet arg1;
+ instance.SetTextures(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRendererSetShaderNegative(void)
+{
+ TestApplication application;
+ Dali::Renderer instance;
+ try
+ {
+ Dali::Shader arg1;
+ instance.SetShader(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRendererGetGeometryNegative(void)
+{
+ TestApplication application;
+ Dali::Renderer instance;
+ try
+ {
+ instance.GetGeometry();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRendererGetTexturesNegative(void)
+{
+ TestApplication application;
+ Dali::Renderer instance;
+ try
+ {
+ instance.GetTextures();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliRendererGetShaderNegative(void)
+{
+ TestApplication application;
+ Dali::Renderer instance;
+ try
+ {
+ instance.GetShader();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3u, TEST_LOCATION );
END_TEST;
}
+
+int UtcDaliSamplerSetWrapModeNegative01(void)
+{
+ TestApplication application;
+ Dali::Sampler instance;
+ try
+ {
+ Dali::WrapMode::Type arg1(static_cast<Dali::WrapMode::Type>(-1));
+ Dali::WrapMode::Type arg2(static_cast<Dali::WrapMode::Type>(-1));
+ instance.SetWrapMode(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliSamplerSetWrapModeNegative02(void)
+{
+ TestApplication application;
+ Dali::Sampler instance;
+ try
+ {
+ Dali::WrapMode::Type arg1(static_cast<Dali::WrapMode::Type>(-1));
+ Dali::WrapMode::Type arg2(static_cast<Dali::WrapMode::Type>(-1));
+ Dali::WrapMode::Type arg3(static_cast<Dali::WrapMode::Type>(-1));
+ instance.SetWrapMode(arg1,arg2,arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliSamplerSetFilterModeNegative(void)
+{
+ TestApplication application;
+ Dali::Sampler instance;
+ try
+ {
+ Dali::FilterMode::Type arg1(static_cast<Dali::FilterMode::Type>(-1));
+ Dali::FilterMode::Type arg2(static_cast<Dali::FilterMode::Type>(-1));
+ instance.SetFilterMode(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliTextureGenerateMipmapsNegative(void)
+{
+ TestApplication application;
+ Dali::Texture instance;
+ try
+ {
+ instance.GenerateMipmaps();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureUploadNegative01(void)
+{
+ TestApplication application;
+ Dali::Texture instance;
+ try
+ {
+ Dali::PixelData arg1;
+ instance.Upload(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureUploadNegative02(void)
+{
+ TestApplication application;
+ Dali::Texture instance;
+ try
+ {
+ Dali::PixelData arg1;
+ unsigned int arg2(0u);
+ unsigned int arg3(0u);
+ unsigned int arg4(0u);
+ unsigned int arg5(0u);
+ unsigned int arg6(0u);
+ unsigned int arg7(0u);
+ instance.Upload(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureGetWidthNegative(void)
+{
+ TestApplication application;
+ Dali::Texture instance;
+ try
+ {
+ instance.GetWidth();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureGetHeightNegative(void)
+{
+ TestApplication application;
+ Dali::Texture instance;
+ try
+ {
+ instance.GetHeight();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliTextureSetSetSamplerNegative(void)
+{
+ TestApplication application;
+ Dali::TextureSet instance;
+ try
+ {
+ unsigned long arg1(0u);
+ Dali::Sampler arg2;
+ instance.SetSampler(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureSetSetTextureNegative(void)
+{
+ TestApplication application;
+ Dali::TextureSet instance;
+ try
+ {
+ unsigned long arg1(0u);
+ Dali::Texture arg2;
+ instance.SetTexture(arg1,arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureSetGetSamplerNegative(void)
+{
+ TestApplication application;
+ Dali::TextureSet instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetSampler(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureSetGetTextureNegative(void)
+{
+ TestApplication application;
+ Dali::TextureSet instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetTexture(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureSetGetTextureCountNegative(void)
+{
+ TestApplication application;
+ Dali::TextureSet instance;
+ try
+ {
+ instance.GetTextureCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
END_TEST;
}
+
+int UtcDaliTypeInfoGetActionNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetActionName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetSignalNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetSignalName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetCreatorNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.GetCreator();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetBaseNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.GetBaseName();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoCreateInstanceNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.CreateInstance();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetActionCountNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.GetActionCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetSignalCountNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.GetSignalCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetPropertyNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ int arg1(0);
+ instance.GetPropertyName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetPropertyCountNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.GetPropertyCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetPropertyIndicesNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ Dali::Vector<int> arg1;
+ instance.GetPropertyIndices(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetChildPropertyNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ int arg1(0);
+ instance.GetChildPropertyName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetChildPropertyTypeNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ int arg1(0);
+ instance.GetChildPropertyType(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetChildPropertyIndexNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ std::string arg1;
+ instance.GetChildPropertyIndex(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetChildPropertyIndicesNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ Dali::Vector<int> arg1;
+ instance.GetChildPropertyIndices(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeInfoGetNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeInfo instance;
+ try
+ {
+ instance.GetName();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeRegistryGetTypeInfoNegative01(void)
+{
+ TestApplication application;
+ Dali::TypeRegistry instance;
+ try
+ {
+ std::string arg1;
+ instance.GetTypeInfo(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeRegistryGetTypeInfoNegative02(void)
+{
+ TestApplication application;
+ Dali::TypeRegistry instance;
+ try
+ {
+ instance.GetTypeInfo(typeid(unsigned int));
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeRegistryGetTypeNameNegative(void)
+{
+ TestApplication application;
+ Dali::TypeRegistry instance;
+ try
+ {
+ unsigned long arg1(0u);
+ instance.GetTypeName(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliTypeRegistryGetTypeNameCountNegative(void)
+{
+ TestApplication application;
+ Dali::TypeRegistry instance;
+ try
+ {
+ instance.GetTypeNameCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / commitdiff