void Update()
    {
        if (UpdateCount == 0)
        {
            IntegrationTest.Assert(_mouse_over.MouseOver == false);
        }
        else if (UpdateCount == 1)
        {
            Vector3 middle_of_screen = new Vector3(Screen.width * 0.5f, Screen.height * 0.5f, 0.0f);
            UnityBridge.Instance.OverrideMousePosition(true, middle_of_screen);
        }
        else if (UpdateCount == 2)
        {
            IntegrationTest.Assert(_mouse_over.MouserOverPreviousFrame == false);
            IntegrationTest.Assert(_mouse_over.MouseOver == true);
        }
        else if (UpdateCount == 3)
        {
            Vector3 left_of_screen = new Vector3(Screen.width * 0.25f, Screen.height * 0.5f, 0.0f);
            UnityBridge.Instance.OverrideMousePosition(true, left_of_screen);
        }
        else if (UpdateCount == 4)
        {
            IntegrationTest.Assert(_mouse_over.MouserOverPreviousFrame == true);
            IntegrationTest.Assert(_mouse_over.MouseOver == false);

            Destroy(_card);

            IntegrationTest.Pass(gameObject);
        }

        UpdateCount++;
    }
Beispiel #2
0
    protected override IEnumerator Run()
    {
        GameObject jauntPlayer       = GameObject.Find("JauntPlayer");
        GameObject jauntPlayerPrefab = PrefabUtility.GetPrefabParent(jauntPlayer) as GameObject;

        jauntPlayerPrefab = Instantiate(jauntPlayerPrefab);
        yield return(null);

        bool success = TestUtilities.CompareObjectToPrefab(jauntPlayer, jauntPlayerPrefab);

        IntegrationTest.Assert(success, "JauntPlayer instance does not match prefab");

        GameObject jauntAutoplay       = GameObject.Find("JauntAutoplay");
        GameObject jauntAutoplayPrefab = PrefabUtility.GetPrefabParent(jauntAutoplay) as GameObject;

        jauntAutoplayPrefab = Instantiate(jauntAutoplayPrefab);
        yield return(null);

        success = TestUtilities.CompareObjectToPrefab(jauntAutoplay, jauntAutoplayPrefab);
        IntegrationTest.Assert(success, "JauntAutoplay instance does not match prefab");

        Destroy(jauntPlayerPrefab);
        Destroy(jauntAutoplayPrefab); //These newly instantiated objects roll over to the next test if not cleaned up

        yield return(null);
    }
Beispiel #3
0
    protected override IEnumerator Run()
    {
        //Check that the JauntPlayer object only has the JauntPlayer script and the Transform component
        GameObject jauntPlayerObj = GameObject.Find("JauntPlayer");

        IntegrationTest.Assert(jauntPlayerObj != null);
        JauntPlayer jauntPlayer = jauntPlayerObj.GetComponent(typeof(JauntPlayer)) as JauntPlayer;

        IntegrationTest.Assert(jauntPlayer != null, "Jaunt Player is null!");

        Destroy(jauntPlayerObj.GetComponent(typeof(JauntPlayer)));
        yield return(null);

        int numComponents = jauntPlayerObj.GetComponents(typeof(Component)).Length;

        IntegrationTest.Assert(numComponents == 1, "Number of JauntPlayer components is " + numComponents + ", should be 1");         //Only the transform component should be left

        //Check that the AutoPlayer object only has the AutoPlayer script and the Transform component
        GameObject jauntAutoplayObj = GameObject.Find("JauntAutoplay");

        IntegrationTest.Assert(jauntAutoplayObj != null);
        JauntAutoplay jauntAutoplay = jauntAutoplayObj.GetComponent(typeof(JauntAutoplay)) as JauntAutoplay;

        IntegrationTest.Assert(jauntAutoplay != null, "JauntAutoplay is null!");

        Destroy(jauntAutoplayObj.GetComponent(typeof(JauntAutoplay)));
        yield return(null);

        numComponents = jauntPlayerObj.GetComponents(typeof(Component)).Length;
        IntegrationTest.Assert(numComponents == 1, "Number of JauntAutoplay components is " + numComponents + ", should be 1");

        yield return(null);
    }
        void OnBlockEnd(Block block)
        {
            IntegrationTest.Assert(started);
            IntegrationTest.Assert(commandExecuted);

            IntegrationTest.Pass();
        }
        private IEnumerator Start()
        {
            IScanner scanner = new Scanner();

            tweaker = new Tweaker();
            TweakerOptions options = TweakerOptions.GetDefaultWithAdditionalFlags(TweakerOptionFlags.IncludeTests);

            tweaker.Init(options, scanner);
            AutoTweakable.Manager = tweaker.Tweakables;
            new TestClass(disposeTweakable: false);
            ITweakable tweakable = tweaker.Tweakables.GetTweakable(new SearchOptions("TestClass.AutoInt#"));

            IntegrationTest.Assert(tweakable != null);
            uint counter = 0u;

            while (tweaker.Tweakables.GetTweakable(new SearchOptions("TestClass.AutoInt#")) != null)
            {
                GC.Collect();
                counter++;
                if (counter > 1000)
                {
                    IntegrationTest.Fail("Failed to finalize AutoTweakable after " + counter + " frames.");
                    yield break;
                }
                yield return(null);
            }
            IntegrationTest.Pass();
        }
Beispiel #6
0
    void Start()
    {
        CoroutineQueue queue = new CoroutineQueue();

        IntegrationTest.Assert(queue.Empty == true);
        IntegrationTest.Pass(gameObject);
    }
Beispiel #7
0
    void Start()
    {
        MatchInfo match = new MatchInfo();

        match.PlayerGoesFirst = true;
        match.PlayerDeckCards = new string[2] {
            "simplecard", "simplecard"
        };
        match.EnemyDeckCards = new string[1] {
            "simplecard"
        };
        match.PlayerStartingHandCards = new string[1] {
            "simplecard"
        };
        match.EnemyStartingHandCards = new string[2] {
            "simplecard", "simplecard"
        };
        GameManager.Instance.StartMatch(match);

        IntegrationTest.Assert(GameManager.Instance.PlayerHand != null);
        IntegrationTest.Assert(GameManager.Instance.PlayerDeck != null);
        IntegrationTest.Assert(GameManager.Instance.EnemyDeck != null);
        IntegrationTest.Assert(GameManager.Instance.EnemyHand != null);

        IntegrationTest.Assert(GameManager.Instance.Settings != null);

        IntegrationTest.Assert(GameManager.Instance.PlayerDeck.Cards.Count == 1);
        IntegrationTest.Assert(GameManager.Instance.EnemyDeck.Cards.Count == 1);

        IntegrationTest.Assert(GameManager.Instance.PlayerHand.Cards.Count == 1);
        IntegrationTest.Assert(GameManager.Instance.EnemyHand.Cards.Count == 2);
    }
Beispiel #8
0
    void Update()
    {
        if (UpdateCount == 0)
        {
            IntegrationTest.Assert(_outline.WantedColor.a <= 0.0f);
        }
        else if (UpdateCount == 1)
        {
            _outline.Request(this, Color.red);
        }
        else if (UpdateCount == 2)
        {
            IntegrationTest.Assert(_outline.WantedColor == Color.red);
            _outline.Request(_outline, Color.black);
        }
        else if (UpdateCount == 3)
        {
            IntegrationTest.Assert(_outline.WantedColor == Color.red);
            _outline.Revoke(this);
        }
        else if (UpdateCount == 4)
        {
            IntegrationTest.Assert(_outline.WantedColor == Color.black);

            Destroy(_card);

            IntegrationTest.Pass(gameObject);
        }

        UpdateCount++;
    }
    void Update()
    {
        if (UpdateCount == 0)
        {
            IntegrationTest.Assert(GameManager.Instance.PlayerDeck.Cards.Count == 2);
            GameManager.Instance.StartPlayerTurn();
        }
        else if (UpdateCount == 1)
        {
            IntegrationTest.Assert(GameManager.Instance.PlayerDeck.Cards.Count == 1);
            GameManager.Instance.StartPlayerTurn();
        }
        else if (UpdateCount == 2)
        {
            IntegrationTest.Assert(GameManager.Instance.PlayerDeck.Cards.Count == 1);

            GameManager.Instance.CleanUpMatch();
        }
        else if (UpdateTime >= 1.5f)
        {
            IntegrationTest.Pass(gameObject);
        }

        UpdateTime += Time.deltaTime;
        UpdateCount++;
    }
 void Update()
 {
     IntegrationTest.Assert(card.GetComponent <HasPhysicalCard>().PhysicalCardGO != null);
     IntegrationTest.Assert(card.GetComponent <HasOutline>().OutlineGO != null);
     Destroy(card);
     IntegrationTest.Pass(gameObject);
 }
Beispiel #11
0
    private IEnumerator TestEmojiInText(Text textComponent, string emojiString)
    {
        chatInputField.text = emojiString;
        yield return(null);

        IntegrationTest.Assert(textComponent.preferredWidth > 0f, "Failed for emojiString: " + emojiString);
    }
 void OnCommandExecute(Block block, Command command, int commandIndex, int maxCommandIndex)
 {
     IntegrationTest.Assert(commandIndex == 0);
     IntegrationTest.Assert(maxCommandIndex == 1);
     IntegrationTest.Assert(command.GetType() == typeof(Wait));
     commandExecuted = true;
 }
Beispiel #13
0
    private IEnumerator TestFaderObjectRemoval()
    {
        yield return(new WaitForFixedUpdate());

        IntegrationTest.Assert(GameObject.Find("Fade") == null, "Fader game object should be removed at the end of fading");
        IntegrationTest.Pass();
    }
        protected override IEnumerator runTest()
        {
            BundleMount bundleMount  = loadAndMount("DependencyBundlesTest/main.unity3d", null, isDependency: false);
            BundleMount bundleMount2 = loadAndMount("DependencyBundlesTest/dep1.unity3d", new HashSet <BundleMount> {
                bundleMount
            }, isDependency: true);
            BundleMount bundleMount3 = loadAndMount("DependencyBundlesTest/dep2.unity3d", new HashSet <BundleMount> {
                bundleMount2, bundleMount
            }, isDependency: true);

            bundleMount.IsPinned = true;
            IntegrationTest.Assert(bundleMount.IsPinned, "DependencyBundlesTest/main.unity3d");
            IntegrationTest.Assert(bundleMount2.IsPinned, "DependencyBundlesTest/dep1.unity3d");
            IntegrationTest.Assert(bundleMount3.IsPinned, "DependencyBundlesTest/dep2.unity3d");
            bundleMount.IsPinned = false;
            IntegrationTest.Assert(!bundleMount.IsPinned, "DependencyBundlesTest/main.unity3d");
            IntegrationTest.Assert(bundleMount2.IsPinned, "DependencyBundlesTest/dep1.unity3d");
            IntegrationTest.Assert(bundleMount3.IsPinned, "DependencyBundlesTest/dep2.unity3d");
            bundleMount3.IsPinned = true;
            IntegrationTest.Assert(!bundleMount.IsPinned, "DependencyBundlesTest/main.unity3d");
            IntegrationTest.Assert(bundleMount2.IsPinned, "DependencyBundlesTest/dep1.unity3d");
            IntegrationTest.Assert(bundleMount3.IsPinned, "DependencyBundlesTest/dep2.unity3d");
            bundleMount.Unload(unloadAllLoadedObjects: true);
            bundleMount2.Unload(unloadAllLoadedObjects: true);
            bundleMount3.Unload(unloadAllLoadedObjects: true);
            yield break;
        }
        protected override IEnumerator runTest()
        {
            string payload = string.Format("{0}embeddedasseta.txt?dl=bundle:mock-create-bundle&b=embedded_asset_test&x=.txt", "assets/rootassets/");

            ContentManifest.AssetEntry entry = ContentManifest.AssetEntry.Parse(payload);
            BundleManager bundleManager      = new BundleManager(null);
            DeviceManager deviceManager      = new DeviceManager();

            deviceManager.Mount(new BundleDevice(deviceManager, bundleManager));
            AssetRequest <TextAsset> request = deviceManager.LoadAsync <TextAsset>(entry.DeviceList, ref entry);

            if (request == null)
            {
                IntegrationTest.Fail("request == null");
            }
            else if (bundleManager.IsMounted(entry.BundleKey))
            {
                IntegrationTest.Fail("Bundle will not be mounted untill after the AssetBundle is created internally.");
            }
            else
            {
                yield return(request);

                IntegrationTest.Assert(bundleManager.IsMounted(entry.BundleKey));
                IntegrationTest.Assert(request.Asset != null);
                bundleManager.UnmountBundle(entry.BundleKey, unloadAllLoadedObjects: false);
            }
            bundleManager.UnmountAllBundles();
        }
Beispiel #16
0
        protected override IEnumerator runTest()
        {
            string payload = "test/test_cube?dl=www-bundle&x=txt";

            ContentManifest.AssetEntry entry            = ContentManifest.AssetEntry.Parse(payload);
            DeviceManager         deviceManager         = new DeviceManager();
            GcsAccessTokenService gcsAccessTokenService = new GcsAccessTokenService(ConfigHelper.GetEnvironmentProperty <string>("GcsServiceAccountName"), new GcsP12AssetFileLoader(ConfigHelper.GetEnvironmentProperty <string>("GcsServiceAccountFile")));
            CPipeManifestService  cpipeManifestService  = new CPipeManifestService("https://storage.googleapis.com/ad37ed76-3a24-91ba-def6-2ff16973c49d.disney.io/", "__mapping_cpremix_dev.json", gcsAccessTokenService);

            deviceManager.Mount(new WwwBundleDevice(deviceManager, gcsAccessTokenService, cpipeManifestService));
            AssetRequest <AssetBundle> request = deviceManager.LoadAsync <AssetBundle>(entry.DeviceList, ref entry);

            IntegrationTestEx.FailIf(request == null);
            IntegrationTestEx.FailIf(request.Finished);
            IntegrationTestEx.FailIf(request.Cancelled);
            yield return(request);

            IntegrationTest.Assert(request.Finished);
            IntegrationTest.Assert(!request.Cancelled);
            IntegrationTest.Assert(request.Asset != null);
            IntegrationTest.Assert(request.Asset.GetAllAssetNames().Length == 1);
            string[] assetNames = request.Asset.GetAllAssetNames();
            IntegrationTest.Assert(assetNames.Contains("assets/bundleassets/test/test_cube.prefab"));
            request.Asset.Unload(unloadAllLoadedObjects: false);
        }
Beispiel #17
0
        protected override IEnumerator runTest()
        {
            string        key       = "embedded_asset_test";
            TextAsset     bundleTxt = Resources.Load <TextAsset>(key + ".unity3d");
            AssetBundle   bundle    = AssetBundle.LoadFromMemory(bundleTxt.bytes);
            BundleManager manager   = Content.BundleManager;
            BundleMount   mount     = manager.MountBundle(key, bundle);
            AsyncAssetBundleRequest <TextAsset> assetRequest = mount.LoadAsync <TextAsset>("embeddedasseta", "embeddedasseta.txt");

            manager.UnmountBundle(key, unloadAllLoadedObjects: false);
            if (manager.IsMounted(key))
            {
                IntegrationTest.Fail("Bundle should not be considered mounted while waiting to unmount.");
            }
            if (!manager.IsUnmounting(key))
            {
                IntegrationTest.Fail("Bundle should be in the process of unmounting.");
            }
            yield return(assetRequest);

            if (assetRequest.Asset == null)
            {
                IntegrationTest.Fail("Failed to load asset");
            }
            yield return(null);

            IntegrationTest.Assert(!manager.IsMounted(key));
            IntegrationTest.Assert(!manager.IsUnmounting(key));
        }
        protected override IEnumerator runTest()
        {
            TextAsset textAsset  = Content.LoadImmediate <TextAsset>("small_text");
            TextAsset textAsset2 = Content.LoadImmediate <TextAsset>("small_text");

            IntegrationTest.Assert(textAsset == textAsset2);
            yield break;
        }
Beispiel #19
0
        protected override IEnumerator runTest()
        {
            TextAsset textAsset = Content.LoadImmediate <TextAsset>("small_text");

            IntegrationTest.Assert(textAsset != null);
            IntegrationTest.Assert(textAsset.text.StartsWith("hello world"));
            yield break;
        }
Beispiel #20
0
        protected override IEnumerator runTest()
        {
            TextAsset textAsset = Content.LoadImmediate <TextAsset>("embeddedasseta");

            IntegrationTest.Assert(textAsset != null);
            IntegrationTest.Assert(textAsset.text.StartsWith("embeddedasseta"));
            yield break;
        }
Beispiel #21
0
    // Use this for initialization
    void Start()
    {
        CoroutineQueue queue = new CoroutineQueue();

        queue.Add(SimpleCoroutines.ExitImmidiately());
        IntegrationTest.Assert(queue.Empty == false);
        IntegrationTest.Pass(gameObject);
    }
Beispiel #22
0
    void Awake()
    {
        GameObject card = CardsGameObjects.OnlyDetachHandle();

        card.AddComponent <CanBeDetached>();
        IntegrationTest.Assert(card.GetComponent <CanBeDetached>().Detached == false);
        Destroy(card);
        IntegrationTest.Pass(gameObject);
    }
Beispiel #23
0
    // Update is called once per frame
    void Run()
    {
        GameObject controlsObj = GameObject.Find("Jaunt2DControls");

        IntegrationTest.Assert(controlsObj != null, "Jaunt2DControls object does not exist!");
        GameObject controlsPrefab = PrefabUtility.GetPrefabParent(controlsObj) as GameObject;

        IntegrationTest.Assert(controlsPrefab != null, "Jaunt2CControls prefab cannot be found!");
    }
Beispiel #24
0
    // Update is called once per frame
    void Update()
    {
        IntegrationTest.Assert(_hand.Cards.Count == 2);
        IntegrationTest.Assert(_deck.Cards.Count == 1);
        _hand.CleanUp();
        _deck.CleanUp();

        IntegrationTest.Pass(gameObject);
    }
Beispiel #25
0
 // Use this for initialization
 void Start()
 {
     Fader.Fade(FadeDirection.In, () => {
         var alpha = GUI.color.a;
         IntegrationTest.Assert(GUI.depth == Fader.drawDepth, "GUI Depth should be set");
         IntegrationTest.Assert(alpha == (int)FadeDirection.In, "Alpha of the GUI color should be equal to FadeDirection.In at the end of the fade");
         StartCoroutine(TestFaderObjectRemoval());
     });
 }
Beispiel #26
0
    void Update()
    {
        if (UpdateCount == 1)
        {
            IntegrationTest.Assert(_card.transform.rotation == Quaternion.Euler(90, 0, 0));
            Destroy(_card);
            IntegrationTest.Pass(gameObject);
        }

        UpdateCount++;
    }
Beispiel #27
0
 public void assertHook(string hookName)
 {
     IntegrationTest.Assert(
         this.Story.CurrentGroup.Style.Get <string>(HarloweStyleSettings.Hook) == hookName,
         string.Format("The current group isn't defined as a Harlowe-hook named'{0}'.", hookName)
         );
     IntegrationTest.Assert(
         this.Story.Output.Reverse <StoryOutput>().Any(output => output.GetAppliedStyle().Get <string>(HarloweStyleSettings.Hook) == hookName),
         string.Format("The Harlowe-hook '{0}' wasn't applied to any output, despite being in scope.", hookName)
         );
 }
        protected override IEnumerator runTest()
        {
            string payload = "small_text?dl=asset:res&x=txt";

            ContentManifest.AssetEntry entry = ContentManifest.AssetEntry.Parse(payload);
            TextAsset textAsset = ResourceLoader <TextAsset> .Load(ref entry);

            IntegrationTest.Assert(textAsset != null);
            IntegrationTest.Assert(textAsset.text.StartsWith("hello world"));
            yield break;
        }
Beispiel #29
0
    void Update()
    {
        IntegrationTest.Assert(_deck.Cards.Count == 2);
        IntegrationTest.Assert(_deck.Cards[0].GetComponent <SimpleCard>() != null);
        IntegrationTest.Assert(_deck.Cards[1].GetComponent <OtherSimpleCard>() != null);

        _deck.CleanUp();
        Destroy(_deck.gameObject);

        IntegrationTest.Pass(gameObject);
    }
Beispiel #30
0
    void Awake()
    {
        Deck deck = Deck.CreateDeck(true);

        IntegrationTest.Assert(deck != null);
        IntegrationTest.Assert(deck.PlayerOwned == true);

        Destroy(deck.gameObject);

        IntegrationTest.Pass(gameObject);
    }