Пример #1
0
        /// <summary>
        /// Generates an arbitrary top load payload based on the maximum version supplied.
        /// </summary>
        /// <param name="random">Random generator for generating arbitrary payloads</param>
        /// <param name="model">The model to add any new types to</param>
        /// <param name="version">Maximum version for generated payloads.</param>
        /// <returns>A top level payload.</returns>
        public static ODataPayloadElement GetRandomPayload(IRandomNumberGenerator random, EdmModel model, ODataVersion version = ODataVersion.V4)
        {
            ExceptionUtilities.CheckArgumentNotNull(random, "random");
            ExceptionUtilities.CheckArgumentNotNull(model, "model");

            Func <ODataPayloadElement>[] payloadCalls = new Func <ODataPayloadElement>[]
            {
                () => { return(GetComplexInstanceCollection(random, model, version)); },
                () => { return(GetComplexProperty(random, model, version)); },
                () => { return(GetDeferredLink()); },
                () => { return(GetLinkCollection()); },
                () => { return(GetEntityInstance(random, model, version)); },
                () => { return(GetEntitySetInstance(random, model)); },
                () => { return(GetODataErrorPayload(random)); },
                () => { return(GetPrimitiveCollection(random)); },
                () => { return(GetPrimitiveProperty(random, model)); },
                () => { return(GetPrimitiveValue(random, model)); },
            };

            payloadCalls.Concat(new Func <ODataPayloadElement>[]
            {
                () => { return(GetComplexMultiValueProperty(random, model, version)); },
                () => { return(GetPrimitiveMultiValueProperty(random)); },
            });

            var payloadCall = random.ChooseFrom(payloadCalls);

            return(payloadCall());
        }
Пример #2
0
        /// <summary>
        /// Generates an arbitrary top load payload based on the maximum version supplied.
        /// </summary>
        /// <param name="random">Random generator for generating arbitrary payloads</param>
        /// <param name="model">The model to add any new types to</param>
        /// <param name="version">Maximum version for generated payloads.</param>
        /// <returns>A top level payload.</returns>
        public static ODataPayloadElement GetRandomPayload(IRandomNumberGenerator random, EdmModel model, ODataVersion version = ODataVersion.V4)
        {
            ExceptionUtilities.CheckArgumentNotNull(random, "random");
            ExceptionUtilities.CheckArgumentNotNull(model, "model");

            Func<ODataPayloadElement>[] payloadCalls = new Func<ODataPayloadElement>[]
            {
                () => { return GetComplexInstanceCollection(random, model, version); }, 
                () => { return GetComplexProperty(random, model, version); }, 
                () => { return GetDeferredLink(); }, 
                () => { return GetLinkCollection(); }, 
                () => { return GetEntityInstance(random, model, version); }, 
                () => { return GetEntitySetInstance(random, model); }, 
                () => { return GetODataErrorPayload(random); }, 
                () => { return GetPrimitiveCollection(random); }, 
                () => { return GetPrimitiveProperty(random, model); }, 
                () => { return GetPrimitiveValue(random, model); },
            };

            payloadCalls.Concat(new Func<ODataPayloadElement>[]
            {
                () => { return GetComplexMultiValueProperty(random, model, version); }, 
                () => { return GetPrimitiveMultiValueProperty(random); },
            });

            var payloadCall = random.ChooseFrom(payloadCalls);
            return payloadCall();
        }
Пример #3
0
    private void FaultyPVC(int num)
    {
        var hot = new Func <bool>[] { () => { Hot.transform.Rotate(Vector3.up, -50f); curKnob = 1; return(false); },
                                      () => { Module.HandleStrike(); DebugLog("Warning: Invalid button [HotMesh] selected."); processingInput = false;  return(false); } };
        var cold  = new Func <bool>[] { () => { Module.HandleStrike(); processingInput = false; return(false); } };
        var basin = new Func <bool>[] { () => { Module.HandleStrike(); DebugLog("Warning: Invalid button [BasinMesh] selected"); processingInput = false; return(false); },
                                        () => { Solve(); return(false); } };
        var ind = new[] { hot, basin, cold.Concat(cold).ToArray() };

        /* I'm not entirely sure why canPress is used here
         * The main method is never accessed, so canPress would always be true */
        var condition = new bool[][] { new[] { true, true, canPress }, new[] { canPress, true, canPress } };

        if (condition[curKnob][num])
        {
            ind[num][curKnob]();
        }
    }
Пример #4
0
        public void TaskAsyncHelpersPreserveCulture()
        {
            TaskCompletionSource<CultureInfo> tcs = null;
            TaskCompletionSource<CultureInfo> uiTcs = null;
            var defaultCulture = Thread.CurrentThread.CurrentCulture;
            var defaultUiCulture = Thread.CurrentThread.CurrentUICulture;
            var testCulture = new CultureInfo("zh-Hans");
            var testUICulture = new CultureInfo("zh-CN");

            Func<Task> saveThreadCulture = () =>
            {
                tcs.SetResult(Thread.CurrentThread.CurrentCulture);
                uiTcs.SetResult(Thread.CurrentThread.CurrentUICulture);
                return TaskAsyncHelper.Empty;
            };

            Action<IEnumerable<Func<Task<object>>>, Action<Task<object>>> ensureCulturePreserved = (taskGenerators, testAction) =>
            {
                foreach (var taskGenerator in taskGenerators)
                {
                    tcs = new TaskCompletionSource<CultureInfo>();
                    uiTcs = new TaskCompletionSource<CultureInfo>();
                    testAction(taskGenerator());
                    Assert.Equal(testCulture, tcs.Task.Result);
                    Assert.Equal(testUICulture, uiTcs.Task.Result);
                }
            };

            try
            {
                Thread.CurrentThread.CurrentCulture = testCulture;
                Thread.CurrentThread.CurrentUICulture = testUICulture;

                var successfulTaskGenerators = new Func<Task<object>>[]
                {
                    () => TaskAsyncHelper.FromResult<object>(null),                                          // Completed
                    () => TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(50)).Then(() => (object)null),     // Async Completed
                };

                // Non-generic Then with sync/async completed tasks
                ensureCulturePreserved(successfulTaskGenerators, task => task.Then(saveThreadCulture));

                var faultedTcs = new TaskCompletionSource<object>();
                var canceledTcs = new TaskCompletionSource<object>();
                faultedTcs.SetException(new Exception());
                canceledTcs.SetCanceled();
                var allTaskGenerators = successfulTaskGenerators.Concat(new Func<Task<object>>[]
                {
                    () => faultedTcs.Task,                                                                   // Faulted
                    () => canceledTcs.Task,                                                                  // Canceled
                    () => TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(50)).Then(() => faultedTcs.Task),  // Async Faulted
                    () => TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(50)).Then(() => canceledTcs.Task), // Async Canceled
                });

                // Generic ContinueWithPreservedCulture with sync/async faulted, canceled and completed tasks
                ensureCulturePreserved(allTaskGenerators, task => task.ContinueWithPreservedCulture(_ => saveThreadCulture()));

                // Verify that threads in the ThreadPool keep the default culture
                tcs = new TaskCompletionSource<CultureInfo>();
                uiTcs = new TaskCompletionSource<CultureInfo>();
                TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(100)).ContinueWith(_ => saveThreadCulture());
                Assert.Equal(defaultCulture, tcs.Task.Result);
                Assert.Equal(defaultUiCulture, uiTcs.Task.Result);
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = defaultCulture;
                Thread.CurrentThread.CurrentUICulture = defaultUiCulture;
            }
        }
        public void TaskAsyncHelpersPreserveCulture()
        {
            TaskCompletionSource <CultureInfo> tcs   = null;
            TaskCompletionSource <CultureInfo> uiTcs = null;
            var defaultCulture   = Thread.CurrentThread.CurrentCulture;
            var defaultUiCulture = Thread.CurrentThread.CurrentUICulture;
            var testCulture      = new CultureInfo("zh-Hans");
            var testUICulture    = new CultureInfo("zh-CN");

            Func <Task> saveThreadCulture = () =>
            {
                tcs.SetResult(Thread.CurrentThread.CurrentCulture);
                uiTcs.SetResult(Thread.CurrentThread.CurrentUICulture);
                return(TaskAsyncHelper.Empty);
            };

            Action <IEnumerable <Func <Task <object> > >, Action <Task <object> > > ensureCulturePreserved = (taskGenerators, testAction) =>
            {
                foreach (var taskGenerator in taskGenerators)
                {
                    tcs   = new TaskCompletionSource <CultureInfo>();
                    uiTcs = new TaskCompletionSource <CultureInfo>();
                    testAction(taskGenerator());
                    Assert.Equal(testCulture, tcs.Task.Result);
                    Assert.Equal(testUICulture, uiTcs.Task.Result);
                }
            };

            try
            {
                Thread.CurrentThread.CurrentCulture   = testCulture;
                Thread.CurrentThread.CurrentUICulture = testUICulture;

                var successfulTaskGenerators = new Func <Task <object> >[]
                {
                    () => TaskAsyncHelper.FromResult <object>(null),                                         // Completed
                    () => TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(50)).Then(() => (object)null),     // Async Completed
                };

                // Non-generic Then with sync/async completed tasks
                ensureCulturePreserved(successfulTaskGenerators, task => task.Then(saveThreadCulture));

                var faultedTcs  = new TaskCompletionSource <object>();
                var canceledTcs = new TaskCompletionSource <object>();
                faultedTcs.SetException(new Exception());
                canceledTcs.SetCanceled();
                var allTaskGenerators = successfulTaskGenerators.Concat(new Func <Task <object> >[]
                {
                    () => faultedTcs.Task,                                                                   // Faulted
                    () => canceledTcs.Task,                                                                  // Canceled
                    () => TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(50)).Then(() => faultedTcs.Task),  // Async Faulted
                    () => TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(50)).Then(() => canceledTcs.Task), // Async Canceled
                });

                // Generic ContinueWithPreservedCulture with sync/async faulted, canceled and completed tasks
                ensureCulturePreserved(allTaskGenerators, task => task.ContinueWithPreservedCulture(_ => saveThreadCulture()));

                // Verify that threads in the ThreadPool keep the default culture
                tcs   = new TaskCompletionSource <CultureInfo>();
                uiTcs = new TaskCompletionSource <CultureInfo>();
                TaskAsyncHelper.Delay(TimeSpan.FromMilliseconds(100)).ContinueWith(_ => saveThreadCulture());
                Assert.Equal(defaultCulture, tcs.Task.Result);
                Assert.Equal(defaultUiCulture, uiTcs.Task.Result);
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture   = defaultCulture;
                Thread.CurrentThread.CurrentUICulture = defaultUiCulture;
            }
        }