Esempio n. 1
1
		public OutputChainBuffer(Sandbox sb, OutputChainBuffer prev, OutputChainBuffer targetOrigin)
		{
			_prevItem = prev;

			if (prev != null)
			{
				prev._nextItem = this;
				_caps = prev is OutputChainArticleBuffer && prev.Caps == Capitalization.First ? Capitalization.None : prev._caps;
			}

			_buffer = targetOrigin._buffer;
			sandbox = sb;
		}
Esempio n. 2
0
        public void RunTests(IEnumerable<TestCase> tests, IRunContext runContext, IFrameworkHandle frameworkHandle)
        {
            this.frameworkHandle = frameworkHandle;

            var testLogger = new TestLogger(frameworkHandle);

            testLogger.SendMainMessage("Execution started");

            foreach (var group in tests.GroupBy(t => t.Source))
            {
                testLogger.SendInformationalMessage(String.Format("Running selected: '{0}'", group.Key));

                try
                {
                    using (var sandbox = new Sandbox<Executor>(group.Key))
                    {
                        var assemblyDirectory = new DirectoryInfo(Path.GetDirectoryName(group.Key));
                        Directory.SetCurrentDirectory(assemblyDirectory.FullName);
                        sandbox.Content.Execute(this, group.Select(t => t.FullyQualifiedName).ToArray());
                    }
                }
                catch (Exception ex)
                {
                    testLogger.SendErrorMessage(ex, String.Format("Exception found while executing tests in group '{0}'", group.Key));

                    // just go on with the next
                }
            }

            testLogger.SendMainMessage("Execution finished");
        }
Esempio n. 3
0
        public override void Init(Sandbox.Common.ObjectBuilders.MyObjectBuilder_CubeBlock objectBuilder, Sandbox.Game.Entities.MyCubeGrid cubeGrid)
        {
            base.Init(objectBuilder, cubeGrid);

            m_oxygenFarmDefinition = BlockDefinition as MyOxygenFarmDefinition;
            IsWorkingChanged += OnIsWorkingChanged;
            NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;

            InitializeConveyorEndpoint();

            PowerReceiver = new MyPowerReceiver(
                MyConsumerGroupEnum.Factory,
                false,
                m_oxygenFarmDefinition.OperationalPowerConsumption,
                ComputeRequiredPower);
            PowerReceiver.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
            PowerReceiver.Update();

            GameLogic = new MySolarGameLogicComponent();
            m_solarComponent = GameLogic as MySolarGameLogicComponent;

            m_solarComponent.Initialize(m_oxygenFarmDefinition.PanelOrientation, m_oxygenFarmDefinition.IsTwoSided, m_oxygenFarmDefinition.PanelOffset, this);

            AddDebugRenderComponent(new Components.MyDebugRenderComponentSolarPanel(this));
        }
Esempio n. 4
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			if (sb.Objects[Name] == null)
				throw new RantRuntimeException(sb.Pattern, _name, $"The subroutine '{Name}' does not exist.");
			var sub = (RADefineSubroutine)sb.Objects[Name].Value;
			if (sub.Parameters.Keys.Count != Arguments.Count)
				throw new RantRuntimeException(sb.Pattern, _name, "Argument mismatch on subroutine call.");
			var action = sub.Body;
			var args = new Dictionary<string, RantAction>();
			var parameters = sub.Parameters.Keys.ToArray();
			for (var i = 0; i < Arguments.Count; i++)
			{
				if (sub.Parameters[parameters[i]] == SubroutineParameterType.Greedy)
				{
					sb.AddOutputWriter();
					yield return Arguments[i];
					var output = sb.Return();
					args[parameters[i]] = new RAText(_name, output.Main);
				}
				else
					args[parameters[i]] = Arguments[i];
			}
			sb.SubroutineArgs.Push(args);
            yield return action;
			sb.SubroutineArgs.Pop();
			yield break;
		}
Esempio n. 5
0
		public OutputWriter(Sandbox sb)
		{
			sandbox = sb;
			mainChain = chains[MainChannelName] = new OutputChain(sb, MainChannelName);
			chainStack.Push(mainChain);
			activeChains.Add(mainChain);
		}
Esempio n. 6
0
 public IEnumerator<RichActionBase> Execute(Sandbox sb)
 {
     List<object> args = new List<object>();
     for (var i = 0; i < _argCount; i++)
         args.Add(new RantObject(sb.ScriptObjectStack.Pop()));
     args.Add(That);
     args.Reverse();
     IEnumerator<RantAction> iterator = null;
     while (true)
     {
         try
         {
             if(iterator == null)
                 iterator = _function.Invoke(sb, args.ToArray());
             if (!iterator.MoveNext())
                 break;
         }
         // attach token to it and throw it up
         catch (RantRuntimeException e)
         {
             e.SetToken(Range);
             throw e;
         }
         yield return iterator.Current as RichActionBase;
     }
 }
        public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
        {
            testLogger = new TestLogger(logger);

            testLogger.SendMainMessage("Discovery started");

            foreach (var source in sources)
            {
                testLogger.SendDebugMessage(String.Format("Processing: '{0}'", source));

                try
                {
                    using (var sandbox = new Sandbox<Discoverer>(source))
                    {
                        if (sandbox.Content != null)
                        {
                            sandbox.Content
                                .DiscoverTests()
                                .Select(name => name.ToTestCase(source))
                                .ForEach(discoverySink.SendTestCase);
                        }
                    }
                }
                catch (Exception ex)
                {
                    testLogger.SendErrorMessage(ex, String.Format("Exception found while discovering tests in source '{0}'", source));

                    // just go on with the next
                }
            }

            testLogger.SendMainMessage("Discovery finished");
        }
        protected internal override TestResult RunImpl(ITestCommand rootTestCommand, Model.Tree.TestStep parentTestStep, TestExecutionOptions options, IProgressMonitor progressMonitor)
        {
            using (progressMonitor.BeginTask("Running tests.", rootTestCommand.TestCount))
            {
                // Note: We do not check options.SkipTestExecution here because we want to build up
                // the tree of data-driven test steps.  So we actually check it later on in the
                // PatternTestExecutor.  This is different from framework adapters
                // at this time (because they do not generally support dynamically generated data-driven tests).
                Sandbox sandbox = new Sandbox();
                EventHandler canceledHandler = delegate { sandbox.Abort(TestOutcome.Canceled, "The user canceled the test run."); };
                try
                {
                    progressMonitor.Canceled += canceledHandler;

                    TestAssemblyExecutionParameters.Reset();

                    PatternTestExecutor executor = new PatternTestExecutor(options, progressMonitor, formatter, converter, environmentManager);

                    // Inlined to minimize stack depth.
                    var action = executor.CreateActionToRunTest(rootTestCommand, parentTestStep, sandbox, null);
                    action.Run();
                    return action.Result;
                }
                finally
                {
                    progressMonitor.Canceled -= canceledHandler;
                    sandbox.Dispose();
                }
            }
        }
Esempio n. 9
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			if (Items == null || ItemsChanged)
			{
				List<RichActionBase> tempItems = new List<RichActionBase>();
				for (var i = 0; i < _items.Count; i++)
				{
					var item = _items[i];
					if (item is RichActionBase)
					{
						yield return item;
						var val = sb.ScriptObjectStack.Pop();
						if (val is RichList && _concatSyntax)
							tempItems.AddRange((val as RichList).Items);
						else
							tempItems.Add(Util.ConvertToAction(item.Range, val));
					}
					else
						tempItems.Add(item);
                }
                Items = tempItems;
                ItemsChanged = false;
			}
			yield break;
		}
Esempio n. 10
0
		public OutputChain(Sandbox sb, string name)
		{
			sandbox = sb;
			_first = new OutputChainBuffer(sb, null);
			_last = _first;
			Name = name;
		}
Esempio n. 11
0
 public override IEnumerator<RantAction> Run(Sandbox sb)
 {
     var iterator = _function.Invoke(sb, new object[] { });
     while (iterator.MoveNext())
         yield return iterator.Current;
     yield break;
 }
Esempio n. 12
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			foreach (RichActionBase action in Group.Actions)
				yield return action;
            if (sb.ScriptObjectStack.Any())
            {
                var obj = sb.ScriptObjectStack.Pop();
                if (obj is RichList)
                {
                    var list = (obj as RichList);
                    // don't make a block from a list with zero items
                    if (list.Items.Count == 0)
                        yield break;
                    List<RantAction> actions = new List<RantAction>();
                    foreach (RichActionBase action in list.Items)
                    {
                        yield return action;
                        var item = sb.ScriptObjectStack.Pop();
                        if (item is RichPatternString)
                            actions.Add((item as RichPatternString).Pattern.Action);
                        else
                            actions.Add(new RAText(action.Range, item.ToString()));
                    }
                    yield return new RABlock(list.Range, actions.ToArray());
                }
                else if (obj is RichPatternString)
                    yield return (obj as RichPatternString).Pattern.Action;
                else if (obj is bool)
                    sb.Print((bool)obj ? "true" : "false");
                else if(!(obj is RantObject && (obj as RantObject).Type == RantObjectType.Undefined))
                    sb.Print(obj);
            }
			yield break;
		}
Esempio n. 13
0
 public override IEnumerator<RantAction> Run(Sandbox sb)
 {
     yield return _expr;
     var expr = sb.ScriptObjectStack.Pop();
     if (!(expr is REAList) && !(expr is REAObject))
         throw new RantRuntimeException(sb.Pattern, Range, "Provided expression is not a list or object.");
     if (expr is REAList)
     {
         yield return expr as REAList;
         var list = sb.ScriptObjectStack.Pop() as REAList;
         var items = (list as REAList).Items;
         for (var i = 0; i < items.Count; i++)
         {
             sb.Objects.EnterScope();
             sb.Objects[_indexName] = new ObjectModel.RantObject(i);
             yield return _body;
             sb.Objects.ExitScope();
         }
         yield break;
     }
     else if (expr is REAObject)
     {
         var items = (expr as REAObject).Values.Keys.ToList();
         foreach (string key in items)
         {
             sb.Objects.EnterScope();
             sb.Objects[_indexName] = new ObjectModel.RantObject(key);
             yield return _body;
             sb.Objects.ExitScope();
         }
         yield break;
     }
 }
Esempio n. 14
0
        public void RunTests(IEnumerable<string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle)
        {
            this.frameworkHandle = frameworkHandle;

            var testLogger = new TestLogger(frameworkHandle);

            testLogger.SendMainMessage("Execution started");

            foreach (var source in sources)
            {
                try
                {
                    using (var sandbox = new Sandbox<Executor>(source))
                    {
                        testLogger.SendInformationalMessage(String.Format("Running: '{0}'", source));

                        var assemblyDirectory = new DirectoryInfo(Path.GetDirectoryName(source));
                        Directory.SetCurrentDirectory(assemblyDirectory.FullName);
                        sandbox.Content.Execute(this);
                    }
                }
                catch (Exception ex)
                {
                    testLogger.SendErrorMessage(ex, String.Format("Exception found while executing tests in source '{0}'", source));

                    // just go on with the next
                }
            }

            testLogger.SendMainMessage("Execution finished");
        }
Esempio n. 15
0
        public static IEnumerable<TestCase> Discover(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink)
        {
            List<TestCase> result = new List<TestCase>();
             // System.Diagnostics.Debugger.Launch();
              var specList = new List<dynamic>();
              foreach (var source in sources)
              {
            using (var sandbox = new Sandbox<Discover>(source))
            {
              List<DefinitionSource> discoveredDefinitions = new List<DefinitionSource>();
              try
              {
             discoveredDefinitions = sandbox.Content.DiscoverSpecsFromCurrentAssembly();
              }
              catch (Exception a)
              {
            Console.WriteLine(a.Message);
              }

              discoveredDefinitions
            .Select(x => AddToSink(source, x, discoverySink))
            .ToList()
            .ForEach(x => result.Add(x));
            }
              }

              return result;
        }
Esempio n. 16
0
 public override IEnumerator<RantAction> Run(Sandbox sb)
 {
     var stackSize = sb.ScriptObjectStack.Count;
     yield return RightSide;
     if (stackSize >= sb.ScriptObjectStack.Count)
         throw new RantRuntimeException(sb.Pattern, Range, "Invalid right side of invert operator.");
     yield break;
 }
Esempio n. 17
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			sb.Objects.EnterScope();
            foreach (RantExpressionAction action in _actions)
                yield return action;
			sb.Objects.ExitScope();
			yield break;
		}
Esempio n. 18
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
            if (LeftSide == null || RightSide == null)
                throw new RantRuntimeException(sb.Pattern, Origin, "Missing part of infix operation.");
			yield return RightSide;
			yield return LeftSide;
			yield break;
		}
Esempio n. 19
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			if (!Actions.Any())
				yield break;
			foreach (RichActionBase action in Actions)
				yield return action;
			yield break;
		}
Esempio n. 20
0
        protected override void Init(Sandbox.Common.ObjectBuilders.Definitions.MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var ob = builder as MyObjectBuilder_CurveDefinition;
            Curve = new Curve();
            foreach (var point in ob.Points)
                Curve.Keys.Add(new CurveKey(point.Time, point.Value));
        }
Esempio n. 21
0
 public override object GetValue(Sandbox sb)
 {
     var rightVal = sb.ScriptObjectStack.Pop();
     if (!(rightVal is bool))
         throw new RantRuntimeException(sb.Pattern, Range,
             "Right side of invert operator must be a boolean value.");
     bool rightBool = (bool)rightVal;
     return !rightBool;
 }
Esempio n. 22
0
		public override object GetValue(Sandbox sb)
		{
			var leftVal = sb.ScriptObjectStack.Pop();
			var rightVal = sb.ScriptObjectStack.Pop();

			if (leftVal is double && rightVal is double)
				return (_orEqual ? (double)leftVal >= (double)rightVal : (double)leftVal > (double)rightVal);
			throw new RantRuntimeException(sb.Pattern, Range, "Invalid " + (leftVal is double ? "right hand" : "left hand") + " side of comparison operator.");
		}
Esempio n. 23
0
		public override object GetValue(Sandbox sb)
		{
            if (RichardFunctions.HasObject(Name))
                return RichardFunctions.GetObject(Name);
			if (sb.Objects[Name] == null) return new RantObject(RantObjectType.Undefined);
			var obj = sb.Objects[Name];
            if (obj.Type == RantObjectType.No)
                return obj;
			return obj.Value;
		}
        public void AddChildWithMatrix(Sandbox.ModAPI.IMyEntity child, ref Matrix childLocalMatrix, bool insertIntoSceneIfNeeded = true)
        {
            child.Hierarchy.Parent = this;

            Children.Add(child.Hierarchy);
            child.WorldMatrix = (MatrixD)childLocalMatrix * Entity.PositionComp.WorldMatrix;

            if (Entity.InScene && !child.InScene && insertIntoSceneIfNeeded)
                child.OnAddedToScene(this);
        }
Esempio n. 25
0
        public override object GetValue(Sandbox sb)
        {
            var leftVal = sb.ScriptObjectStack.Pop();
            var rightVal = sb.ScriptObjectStack.Pop();

            if (!(leftVal is bool))
                throw new RantRuntimeException(sb.Pattern, Range, "Invalid left hand side of boolean OR operator.");
            if (!(rightVal is bool))
                throw new RantRuntimeException(sb.Pattern, Range, "Invalid right hand side of boolean OR operator.");

            return (bool)leftVal || (bool)rightVal;
        }
Esempio n. 26
0
 private bool TransferItemsTo(Sandbox.ModAPI.Interfaces.IMyInventory dst, int sourceItemIndex, int? targetItemIndex, VRage.MyFixedPoint? amount,bool useConveyor)
 {
     MyInventory dstInventory = dst as MyInventory;
     if (dstInventory != null)
     {
         if (sourceItemIndex < 0 || sourceItemIndex >= this.m_items.Count || (useConveyor == true && IsConnected(dstInventory) == false))
         {
             return false;
         }
         Transfer(this as MyInventory, dstInventory, this.GetItems()[sourceItemIndex].ItemId, targetItemIndex.HasValue ? targetItemIndex.Value : -1, amount);
         return true;
     }
     return false;
 }
Esempio n. 27
0
        public void RunTests(IEnumerable<TestCase> tests, IRunContext runContext, IFrameworkHandle frameworkHandle)
        {
            this.frameworkHandle = frameworkHandle;

            foreach (var group in tests.GroupBy(t => t.Source))
            {
                frameworkHandle.SendMessage(TestMessageLevel.Informational, "Running selected: " + group.Key);

                using (var sandbox = new Sandbox<Executor>(group.Key))
                {
                    sandbox.Content.Execute(this, group.Select(t => t.FullyQualifiedName).ToArray());
                }
            }
        }
Esempio n. 28
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			object func = _function;
			if (
                func is RichVariable || 
                func is RichFunctionCall || 
                func is RichGroup ||
                func is RichObjectProperty)
			{
                var count = sb.ScriptObjectStack.Count;
				yield return (func as RichActionBase);
                if (count >= sb.ScriptObjectStack.Count)
                    throw new RantRuntimeException(sb.Pattern, Range, "Invalid function call target.");
				func = sb.ScriptObjectStack.Pop();
			}
            if (func is RichFunction)
            {
                var expectedCount = (func as RichFunction).ArgCount;
                if (expectedCount != _argValues.Length)
                    throw new RantRuntimeException(sb.Pattern, Range, $"Function expected {expectedCount} arguments, got {_argValues.Length}.");
                foreach (RichActionBase argAction in _argValues)
                    yield return argAction;
                var iterator = (func as RichFunction).Execute(sb);
                while (iterator.MoveNext())
                    yield return iterator.Current;
                yield break;
            }
            else if (func is RichPatternString)
            {
                if (_argValues.Length > 0)
                    throw new RantRuntimeException(sb.Pattern, base.Range, "Unexpected arguments for pattern string.");
                yield return (func as RichPatternString).Execute(sb);
                yield break;
            }
            else if (func is RichNativeFunction)
            {
                var expectedCount = (func as RichNativeFunction).ArgCount;
                if (expectedCount != _argValues.Length)
                    throw new RantRuntimeException(sb.Pattern, Range, $"Native function expected {expectedCount} arguments, got {_argValues.Length}.");
                foreach (RichActionBase argAction in _argValues)
                    yield return argAction;
                // we have to set this for reasons
                (func as RichNativeFunction).Range = this.Range;
                var iterator = (func as RichNativeFunction).Execute(sb);
                while (iterator.MoveNext())
                    yield return iterator.Current;
                yield break;
            }
			throw new RantRuntimeException(sb.Pattern, base.Range, "Cannot execute " + Util.ScriptingObjectType(func) + " as function.");
		}
Esempio n. 29
0
		public override IEnumerator<RantAction> Run(Sandbox sb)
		{
			yield return _expression;
			var result = sb.ScriptObjectStack.Pop();
			if (!(result is bool))
				throw new RantRuntimeException(sb.Pattern, Range, "Expected boolean value in if statement.");
			sb.Objects.EnterScope();
            if ((bool)result)
                yield return _body;
            else if (_elseBody != null)
                yield return _elseBody;
			sb.Objects.ExitScope();
			yield break;
		}
Esempio n. 30
0
		public override object GetValue(Sandbox sb)
		{
			if (LeftSide == null || RightSide == null)
				throw new RantRuntimeException(sb.Pattern, Origin, "Both sides of infix operation must be defined.");
			var leftValue = sb.ScriptObjectStack.Pop();
			var rightValue = sb.ScriptObjectStack.Pop();
            if (!(leftValue is double))
				throw new RantRuntimeException(sb.Pattern, Origin, "Left side of infix operation must be a number.");
			if (!(rightValue is double))
				throw new RantRuntimeException(sb.Pattern, Origin, "Right side of infix operation must be a number.");
            if (this is RichDivisionOperator && (double)rightValue == 0)
                throw new RantRuntimeException(sb.Pattern, Origin, "Cannot divide by zero.");
            return Operation((double)leftValue, (double)rightValue);
		}
Esempio n. 31
0
        private Type[] GetKnownTypes()
        {
            if (CompiledAssembly == null)
            {
                throw new Exception("Assembly is not compiled yet");
            }
            var assemblies = _cSharpProject.MetadataReferences.Select(i =>
            {
                if (i is PortableExecutableReference g)
                {
                    return(Sandbox.LoadByFullFilename(g.FilePath).WrappedAssembly);
                }
                throw new NotSupportedException(i.GetType().FullName);
            }).ToList();

            assemblies.Add(CompiledAssembly);
            return(CompileState.GetAllTypes(assemblies));
        }
Esempio n. 32
0
        private void LogData_NewEntry(object sender, DataLogOutput.LogEntryEventArgs e)
        {
            if (this.InvokeRequired)
            {
                return;
            }
            bool pause =
                e.Entry.Type == LogMessageType.Error &&
                this.buttonPauseOnError.Checked &&
                Sandbox.State == SandboxState.Playing &&
                !Sandbox.IsChangingState;

            if (pause)
            {
                System.Media.SystemSounds.Hand.Play();
                Sandbox.Pause();
            }
        }
Esempio n. 33
0
        public async Task CheckProcessTreeTimoutOnReportQueueStarvationAndStuckRootProcessAsync()
        {
            var processInfo = CreateProcessInfoWithSandboxConnection(Operation.Block());

            processInfo.ReportQueueProcessTimeoutForTests = TimeSpan.FromMilliseconds(10);

            // Set the last enqueue time to now
            s_connection.MinReportQueueEnqueueTime = Sandbox.GetMachAbsoluteTime();
            using (var process = CreateAndStartSandboxedProcess(processInfo, measureTime: true))
            {
                // Post nothing to the report queue, and the process tree must be timed out after ReportQueueProcessTimeout
                // has been reached, including the stuck root process
                var result = await process.GetResultAsync();

                XAssert.IsTrue(result.Killed, "Expected process to have been killed");
                XAssert.IsFalse(result.TimedOut, "Didn't expect process to have timed out");
            }
        }
Esempio n. 34
0
        public void ShouldExecuteHookAndReportFailureOnException(string hookType)
        {
            var expression = Hooks[hookType];

            _mockHookRegistry.Setup(registry => registry.MethodFor(MethodName))
            .Returns(mockHookMethodInfo.Object);
            _mockHookRegistry.Setup(expression).Returns(_hookMethods).Verifiable();

            reflectionWrapper.Setup(x => x.Invoke(mockHookMethodInfo.Object, mockInstance.Object, new object[] { }))
            .Throws(new Exception("foo"))
            .Verifiable();

            var sandbox         = new Sandbox(_mockAssemblyLoader.Object, _mockHookRegistry.Object, activatorWrapper.Object, reflectionWrapper.Object);
            var executionResult = sandbox.ExecuteHooks(hookType, _mockStrategy.Object, _applicableTags, new ExecutionContext());

            Assert.False(executionResult.Success);
            Assert.AreEqual("foo", executionResult.ExceptionMessage);
        }
Esempio n. 35
0
        AvailableDatasets MapToAvailable(Sandbox sandbox)
        {
            var availableDatasets = sandbox.Study
                                    .StudyDatasets
                                    .Select(sd => new AvailableDatasetItem()
            {
                DatasetId      = sd.DatasetId,
                Name           = sd.Dataset.Name,
                Classification = sd.Dataset.Classification,
                AddedToSandbox = sd.Dataset.SandboxDatasets.Where(sd => sd.SandboxId == sandbox.Id).Any()
            });

            var result = new AvailableDatasets(availableDatasets);

            DatasetClassificationUtils.SetRestrictionProperties(result);

            return(result);
        }
Esempio n. 36
0
        public override object GetValue(Sandbox sb)
        {
            if (RichardFunctions.HasObject(Name))
            {
                return(RichardFunctions.GetObject(Name));
            }
            if (sb.Objects[Name] == null)
            {
                return(new RantObject(RantObjectType.Undefined));
            }
            var obj = sb.Objects[Name];

            if (obj.Type == RantObjectType.No)
            {
                return(obj);
            }
            return(obj.Value);
        }
Esempio n. 37
0
        public OutputChainBuffer(Sandbox sb, OutputChainBuffer prev)
        {
            _prevItem = prev;

            if (prev != null)
            {
                prev._nextItem = this;
                _caps          = prev is OutputChainArticleBuffer && prev.Caps == Capitalization.First ? Capitalization.None : prev._caps;
                _numberFormatter.BinaryFormat       = prev.NumberFormatter.BinaryFormat;
                _numberFormatter.BinaryFormatDigits = prev.NumberFormatter.BinaryFormatDigits;
                _numberFormatter.Endianness         = prev.NumberFormatter.Endianness;
                _numberFormatter.NumberFormat       = prev.NumberFormatter.NumberFormat;
            }

            _isTarget = true;
            _buffer   = new StringBuilder(InitialCapacity);
            sandbox   = sb;
        }
Esempio n. 38
0
        public void ShouldLoadClassInstanceManager()
        {
            var mockAssemblyLoader      = new Mock <IAssemblyLoader>();
            var mockInstanceManagerType = new Mock <Type>();

            mockAssemblyLoader.Setup(loader => loader.ClassInstanceManagerType)
            .Returns(mockInstanceManagerType.Object);
            var activatorWrapper    = new Mock <IActivatorWrapper>();
            var mockInstanceManager = new Mock <object>();

            activatorWrapper.Setup(x => x.CreateInstance(mockInstanceManagerType.Object))
            .Returns(mockInstanceManager.Object)
            .Verifiable();
            var mockTypeWrapper = new Mock <IReflectionWrapper>();
            var sandbox         = new Sandbox(mockAssemblyLoader.Object, null, activatorWrapper.Object, mockTypeWrapper.Object);

            activatorWrapper.VerifyAll();
        }
Esempio n. 39
0
        static void AddDatasets(bool addDatasets, Study study, Sandbox sandbox)
        {
            if (addDatasets)
            {
                if (study.StudyDatasets != null)
                {
                    sandbox.SandboxDatasets = new List <SandboxDataset>();

                    foreach (var curDs in study.StudyDatasets)
                    {
                        sandbox.SandboxDatasets.Add(new SandboxDataset()
                        {
                            DatasetId = curDs.DatasetId, Sandbox = sandbox, Added = DateTime.UtcNow, AddedBy = "seed"
                        });
                    }
                }
            }
        }
Esempio n. 40
0
        public async Task SpringCloudConfigServer_WithHealthEnabled_ReturnsHealth()
        {
            // These settings match the default java config server
            var appsettings = @"
                {
                    ""spring"": {
                      ""application"": {
                        ""name"": ""foo""
                      },
                      ""cloud"": {
                        ""config"": {
                            ""uri"": ""http://localhost:8888"",
                            ""env"": ""development"",
                            ""health"": {
                                ""enabled"": true
                            },
                            ""failfast"": ""true""
                        }
                      }
                    }
                }";

            using var sandbox = new Sandbox();
            var path      = sandbox.CreateFile("appsettings.json", appsettings);
            var directory = Path.GetDirectoryName(path);
            var fileName  = Path.GetFileName(path);
            var builder   = new WebHostBuilder()
                            .UseStartup <TestServerStartup>()
                            .ConfigureAppConfiguration((context, config) =>
            {
                config.SetBasePath(directory)
                .AddJsonFile(fileName)
                .AddConfigServer(context.HostingEnvironment);
            });

            // Act and Assert (TestServer expects Spring Cloud Config server to be running)
            using var server = new TestServer(builder);
            using var client = server.CreateClient();
            var result = await client.GetStringAsync("http://localhost/Home/Health");

            // after switching to newer config server image, the health response has changed to
            // https://github.com/spring-cloud-samples/config-repo/Config resource 'file [/tmp/config-repo-4389533880216684481/application.yml' via location '' (document #0)"
            Assert.StartsWith("UP,https://github.com/spring-cloud-samples/config-repo/foo-development.properties,https://github.com/spring-cloud-samples/config-repo/foo.properties,https://github.com/spring-cloud-samples/config-repo/Config", result);
        }
Esempio n. 41
0
        public static string LiteralValue(this Sandbox sandbox)
        {
            switch (sandbox)
            {
            case Sandbox.AllowForms: return("allow-forms");

            case Sandbox.AllowPointerLock: return("allow-pointer-lock");

            case Sandbox.AllowPopups: return("allow-popups");

            case Sandbox.AllowSameOrigin: return("allow-same-origin");

            case Sandbox.AllowScripts: return("allow-scripts");

            case Sandbox.AllowTopNavigation: return("allow-top-navigation");

            default: throw new ArgumentException();
            }
        }
        public void AddConfigServer_IniAppSettingsConfiguresClient()
        {
            var appsettings = @"
[spring:cloud:config]
    uri=https://foo.com:9999
    enabled=false
    failFast=false
    label=myLabel
    name=myName
    username=myUsername
    password=myPassword
";

            using var sandbox = new Sandbox();
            var path                 = sandbox.CreateFile("appsettings.json", appsettings);
            var directory            = Path.GetDirectoryName(path);
            var fileName             = Path.GetFileName(path);
            var configurationBuilder = new ConfigurationBuilder();

            configurationBuilder.SetBasePath(directory);

            var csettings = new ConfigServerClientSettings();

            configurationBuilder.AddIniFile(fileName);

            configurationBuilder.AddConfigServer(csettings);
            var config = configurationBuilder.Build();

            var configServerProvider =
                config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();

            Assert.NotNull(configServerProvider);
            var settings = configServerProvider.Settings;

            Assert.False(settings.Enabled);
            Assert.False(settings.FailFast);
            Assert.Equal("https://foo.com:9999", settings.Uri);
            Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment);
            Assert.Equal("myName", settings.Name);
            Assert.Equal("myLabel", settings.Label);
            Assert.Equal("myUsername", settings.Username);
            Assert.Equal("myPassword", settings.Password);
        }
Esempio n. 43
0
        public async Task CheckProcessTreeTimoutOnReportQueueStarvationAndStuckRootProcessAsync()
        {
            var processInfo = CreateProcessInfoWithSandboxConnection(Operation.Block());

            // Set the last enqueue time to now
            s_connection.MinReportQueueEnqueueTime = Sandbox.GetMachAbsoluteTime();
            var process = CreateAndStartSandboxedProcess(processInfo, measureTime: true);
            var taskCancelationSource = new CancellationTokenSource();

            // Post nothing to the report queue, and the process tree must be timed out after ReportQueueProcessTimeout
            // has been reached, including the stuck root process
            ContinouslyPostAccessReports(process, taskCancelationSource.Token);
            var result = await process.GetResultAsync();

            taskCancelationSource.Cancel();

            XAssert.IsTrue(result.Killed, "Expected process to have been killed");
            XAssert.IsFalse(result.TimedOut, "Didn't expect process to have timed out");
        }
Esempio n. 44
0
        public void Create_multiple_process_in_limit_should_be_ok(int limitCount, int createCount, bool result)
        {
            // Arrange
            using (var compiler = new CSharpCompiler())
            {
                var asm = compiler.Compile(Code);

                var info = new SandboxRunInfo
                {
                    LimitProcessCount = limitCount,
                    MemoryLimitMb     = 40.0f,
                    Path        = asm.PathToAssembly,
                    TimeLimitMs = 1000,
                };

                var ior = Sandbox.BeginRun(info);
                using (var writer = new StreamWriter(ior.InputWriteStream))
                {
                    writer.Write(createCount);
                }

                var res = Sandbox.EndRun(ior.InstanceHandle);

                res.Succeed.Should().BeTrue();

                if (result)
                {
                    res.ExitCode.Should().Be(0);
                }
                else
                {
                    res.ExitCode.Should().NotBe(0);
                }

                res.TimeMs.Should().BeLessThan(info.TimeLimitMs);
                res.MemoryMb.Should().BeLessThan(info.MemoryLimitMb);

                Console.WriteLine("Time: {0}ms", res.TimeMs);
                Console.WriteLine("Memory: {0}MB", res.MemoryMb);
                Console.WriteLine(info.Path);
                Thread.Sleep(10);
            }
        }
Esempio n. 45
0
        public void SuccessIsFalseOnSerializableExceptionThrown()
        {
            const string expectedMessage   = "I am a custom serializable exception";
            var          reflectionWrapper = new ReflectionWrapper();
            var          assemblyLoader    = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
            var          sandbox           = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), new ActivatorWrapper(), reflectionWrapper);

            var stepMethods = sandbox.GetStepMethods();
            var gaugeMethod = stepMethods.First(info =>
                                                string.CompareOrdinal(info.Name,
                                                                      "IntegrationTestSample.StepImplementation.ThrowSerializableException") == 0);

            var executionResult = sandbox.ExecuteMethod(gaugeMethod);

            Assert.False(executionResult.Success);
            Assert.AreEqual(expectedMessage, executionResult.ExceptionMessage);
            StringAssert.Contains("IntegrationTestSample.StepImplementation.ThrowSerializableException",
                                  executionResult.StackTrace);
        }
Esempio n. 46
0
        static CloudResource CreateFailedVmResource(Sandbox sandbox,
                                                    CloudResource sandboxResourceGroup,
                                                    string studyName,
                                                    string nameSuffix,
                                                    string configString           = null,
                                                    string statusOfFailedResource = CloudResourceOperationState.FAILED,
                                                    int tryCount         = CloudResourceConstants.RESOURCE_MAX_TRY_COUNT,
                                                    int maxTryCount      = CloudResourceConstants.RESOURCE_MAX_TRY_COUNT,
                                                    bool deleted         = false,
                                                    bool deleteSucceeded = false)
        {
            var vmResourceName = AzureResourceNameUtil.VirtualMachine(studyName, sandbox.Name, nameSuffix);

            var vmResource = CloudResourceFactory.CreateFailing(sandboxResourceGroup.Region, AzureResourceType.VirtualMachine, sandboxResourceGroup.ResourceName, vmResourceName, parentResource: sandboxResourceGroup, statusOfFailedResource: statusOfFailedResource, tryCount: tryCount, maxTryCount: maxTryCount, deleted: deleted, deleteSucceeded: deleteSucceeded);

            vmResource.SandboxId    = sandbox.Id;
            vmResource.ConfigString = configString;
            return(vmResource);
        }
Esempio n. 47
0
        private void ExecutePendingActions()
        {
            var sandboxLoader = new SandboxLoader(_filesystem);

            while (!_isDisposed)
            {
                PendingAction action;
                while (_pendingActions.TryDequeue(out action))
                {
                    Execute(sandboxLoader, action);
                }

                // TODO: We should probably add a delay

                _currentSandbox = sandboxLoader.CreateSandbox();

                Thread.Sleep(TimeSpan.FromMilliseconds(100));
            }
        }
        private void Update(Sandbox sandbox, FileInfo fileInfo)
        {
            using (ExcelPackage package = new ExcelPackage(fileInfo))
            {
                ExcelWorkbook  book  = package.Workbook;
                ExcelWorksheet sheet = book.Worksheets[sheetName];

                int rowNum = GetRowNumberFromSandBox(sandbox, sheet);

                sheet.Cells[rowNum, 1].Value = sandbox.SandboxNumber;
                sheet.Cells[rowNum, 2].Value = sandbox.Developer;
                sheet.Cells[rowNum, 3].Value = sandbox.DateLastDeployed;
                sheet.Cells[rowNum, 4].Value = sandbox.Status;
                sheet.Cells[rowNum, 5].Value = sandbox.UserStory;
                sheet.Cells[rowNum, 6].Value = sandbox.Deployable;

                Save(package);
            }
        }
Esempio n. 49
0
        public void CallingNextPhase_WithSeveralPhases_LastPhaseBegingDataAvailable_WillThrow()
        {
            var sandboxWithoutPhase = new Sandbox()
            {
                PhaseHistory = new List <SandboxPhaseHistory>()
                {
                    new SandboxPhaseHistory()
                    {
                        Counter = 0, Phase = SandboxPhase.Open
                    },
                    new SandboxPhaseHistory()
                    {
                        Counter = 1, Phase = SandboxPhase.DataAvailable
                    }
                }
            };

            Assert.Throws <Exception>(() => SandboxPhaseUtil.GetNextPhase(sandboxWithoutPhase));
        }
Esempio n. 50
0
            public AssemblyUsage(string fullname)
            {
                Evidence e   = new Evidence();
                var      ads = new AppDomainSetup {
                    ApplicationBase = Path.GetDirectoryName(fullname)
                };

                this.Sandbox = AppDomain.CreateDomain("test", e, ads, new PermissionSet(PermissionState.Unrestricted));
                new Mapper(Sandbox);


                try {
                    var assembly = Sandbox.Load(Path.GetFileNameWithoutExtension(fullname));
                    this.Assembly = assembly;
                }
                catch (Exception ex) {
                    this.Assembly = Assembly.Load(File.ReadAllBytes(fullname));
                }
            }
Esempio n. 51
0
        public void ShouldGetAllStepTexts()
        {
            var reflectionWrapper = new ReflectionWrapper();
            var assemblyLoader    = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
            var sandbox           = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), new ActivatorWrapper(), reflectionWrapper);

            var stepTexts = sandbox.GetAllStepTexts().ToList();

            new List <string>
            {
                "Say <what> to <who>",
                "A context step which gets executed before every scenario",
                "Step that takes a table <table>",
                "Refactoring Say <what> to <who>",
                "Refactoring 1 Say <what> to <who>",
                "Refactoring A context step which gets executed before every scenario",
                "Refactoring Step that takes a table <table>"
            }.ForEach(s => Assert.Contains(s, stepTexts));
        }
Esempio n. 52
0
 public override IEnumerator <RST> Run(Sandbox sb)
 {
     if (sb.Objects.ContainsKey(Name) && CheckIfSubroutineList(sb.Objects[Name]))
     {
         var subroutines = sb.Objects[Name].Value as List <RantObject>;
         if (subroutines.Any(s => (s.Value as RstDefineSubroutine).Parameters.Count == Parameters.Count))
         {
             subroutines.RemoveAll(s => (s.Value as RstDefineSubroutine).Parameters.Count == Parameters.Count);
         }
         subroutines.Add(new RantObject(this));
     }
     else
     {
         var list = new List <RantObject>();
         list.Add(new RantObject(this));
         sb.Objects[Name] = new RantObject(list);
     }
     yield break;
 }
Esempio n. 53
0
        public MainForm()
        {
            InitializeComponent();

            //создаем песочницу
            sb = new Sandbox();
            //создаем инструмент рсования
            tools = new Tools()
            {
                Sandbox = sb
            };

            cbTool.SelectedIndex = 0;
            pnSandbox.Sandbox    = sb;

            //запускаем моделирование физики в отдельном потоке
            ThreadPool.QueueUserWorkItem((_) =>
            {
                var sw = new Stopwatch();
                //цикл моделирования физики
                const float dt = 0.25f;
                while (true)
                {
                    sw.Restart();
                    sb.Update((float)dt);
                    physCounter++;
                    var el = (int)sw.ElapsedMilliseconds;
                    if (el < 20)
                    {
                        Thread.Sleep(20 - el);//ограничиваем FPS
                    }
                }
            });

            //запускаем таймер обновления интерфейса
            new System.Windows.Forms.Timer {
                Enabled = true, Interval = 15
            }.Tick += delegate { UpdateCreator(); pnSandbox.Invalidate(); };
            //запускаем таймер FPS
            new System.Windows.Forms.Timer {
                Enabled = true, Interval = 1000
            }.Tick += CalcFPS;
        }
        bool AllSandboxResourcesOkay(Sandbox sandbox)
        {
            if (sandbox.Resources == null)
            {
                throw new Exception("Missing include for Sandbox.Resources");
            }

            foreach (var currentSandboxResource in CloudResourceUtil.GetSandboxControlledResources(sandbox.Resources))
            {
                //If create operation failed

                if (!CloudResourceOperationUtil.HasSuccessfulCreateOperation(currentSandboxResource))
                {
                    return(false);
                }
            }

            return(true);
        }
Esempio n. 55
0
        public void Create_calc_should_return_success()
        {
            // arrange
            var calc = new JudgeInfo
            {
                Path          = "calc.exe",
                MemoryLimitMb = 10.0f,
                TimeLimitMs   = 100,
                Input         = null
            };

            // act
            var result = Sandbox.Judge(calc);

            // assert
            result.Succeed.Should().BeTrue();
            result.ErrorCode.Should().Be(0);
            result.MemoryMb.Should().BeGreaterThan(0);
        }
Esempio n. 56
0
        public void should_broadcast_occupy_message_to_peers()
        {
            var evt = new ManualResetEvent(false);
            //var synService = Substitute.For<IMigrationNumberSync>();
            //var publisher = Substitute.For<IEventPublisher>();
            var synService = Substitute.For <IMigrationNumberSync>();

            synService.WhenForAnyArgs(x => x.Occupy(new Migration())).Do(c => evt.Set());

            //new MigrationNumberSyncService(publisher);
            var localPeer = new MigrationNumberSyncPeer(synService);

            localPeer.Start(521);
            try
            {
                // act
                Sandbox.Execute(() =>
                {
                    var remotePeer =
                        new MigrationNumberSyncPeer(new MigrationNumberSyncService(new EventPublisher(), new CallbackChannelProvider()));
                    remotePeer.Start(125);
                    try
                    {
                        remotePeer.Channel.Occupy(new Migration {
                            Number = "1", ProjectId = "2"
                        });
                    }
                    finally
                    {
                        remotePeer.Stop();
                    }
                });

                // assert
                evt.WaitOne(400000, false);
                //publisher.Received().Publish(Arg.Is<OccupyEvent>(e => e.Number == "1" && e.ProjectId == "1"));
                synService.ReceivedWithAnyArgs().Occupy(Arg.Is <Migration>(m => m.Number == "1" && m.ProjectId == "2"));
            }
            finally
            {
                localPeer.Stop();
            }
        }
Esempio n. 57
0
        public void ShouldReorderParameters()
        {
            const string newStepValue      = "Refactoring Say <who> to <what>";
            var          reflectionWrapper = new ReflectionWrapper();
            var          activatorWrapper  = new ActivatorWrapper();
            var          assemblyLoader    = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
            var          sandbox           = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);
            var          gaugeMethod       = sandbox.GetStepMethods().First(info =>
                                                                            info.Name == "IntegrationTestSample.RefactoringSample.RefactoringSaySomething-StringwhatStringwho");

            var parameterPositions = new[] { new Tuple <int, int>(0, 1), new Tuple <int, int>(1, 0) };

            sandbox.Refactor(gaugeMethod, parameterPositions, new List <string> {
                "who", "what"
            }, newStepValue);

            AssertStepAttributeWithTextExists(gaugeMethod.Name, newStepValue);
            AssertParametersExist(gaugeMethod.Name, new[] { "who", "what" });
        }
Esempio n. 58
0
        public void ShouldAddParametersWithReservedKeywordName()
        {
            const string newStepValue      = "Refactoring this is a test step <class>";
            var          reflectionWrapper = new ReflectionWrapper();
            var          activatorWrapper  = new ActivatorWrapper();
            var          assemblyLoader    = new AssemblyLoader(new AssemblyWrapper(), new AssemblyLocater(new DirectoryWrapper(), new FileWrapper()).GetAllAssemblies(), reflectionWrapper);
            var          sandbox           = new Sandbox(assemblyLoader, new HookRegistry(assemblyLoader), activatorWrapper, reflectionWrapper);

            var gaugeMethod = sandbox.GetStepMethods().First(info =>
                                                             info.Name == "IntegrationTestSample.RefactoringSample.RefactoringSampleTest");
            var parameterPositions = new[] { new Tuple <int, int>(-1, 0) };

            sandbox.Refactor(gaugeMethod, parameterPositions, new List <string> {
                "class"
            }, newStepValue);

            AssertStepAttributeWithTextExists(gaugeMethod.Name, newStepValue);
            AssertParametersExist(gaugeMethod.Name, new[] { "@class" });
        }
        static void Main(string[] args)
        {
            var uri =
                new Uri("http://localhost:3579");

            using (var host = new NancyHost(uri))
            {
                host.Start();

                var guid = new Guid("e28b7426-c328-49fc-b3c2-e9f225b534e9");
                var exam = new Exam("Title", guid, new List <BaseQuestion>());

                Sandbox.AddExamToSandbox(exam);

                Console.WriteLine("Your application is running on " + uri);
                Console.WriteLine("Press any [Enter] to close the host.");
                Console.ReadLine();
            }
        }
Esempio n. 60
0
        public async Task ShouldBuildCorrectMainScriptContentWithSingleScript()
        {
            IList <string> actualScripts = new List <string>();

            IOptions options = new Options();
            ISandboxConfigurationBuilder configurationBuilder = new SandboxConfigurationBuilder(new Options());

            Action <string> createDirectory   = path => { };
            Action <string> deleteFiles       = path => { };
            Action <string> deleteDirectories = path => { };

            Func <string, Task> startProcess = path => Task.CompletedTask;
            Func <string, byte[], CancellationToken, Task> writeAllBytes = (path, content, token) => Task.CompletedTask;
            Func <string, string, CancellationToken, Task> copyFiles     = (source, destination, token) => Task.CompletedTask;
            Func <IList <string>, IPowershellTranslator, string, IOptions, Task <LiteralScript> > literalScriptFactory = async(scripts, translator, name, options) =>
            {
                actualScripts = scripts;
                var literalScript = new LiteralScript(scripts, translator, name, writeAllBytes);
                await literalScript.Process(options);

                return(literalScript);
            };

            var sandbox = new Sandbox(options, configurationBuilder, createDirectory, deleteFiles, deleteDirectories, startProcess, literalScriptFactory);
            await sandbox.Run(
                // Raw script that will be executed
                new LiteralScript(new List <string>()
            {
                @"Start-Process 'C:\windows\system32\notepad.exe'"
            },
                                  new PowershellTranslator(null, () => 1000),
                                  "mockScriptName1.ps1",
                                  writeAllBytes));

            IList <string> expected = new List <string>()
            {
                @"powershell.exe -ExecutionPolicy Bypass -File C:\Users\WDAGUtilityAccount\Desktop\Sandbox\mockScriptName1.ps1 3>&1 2>&1 > ""C:\Users\WDAGUtilityAccount\Desktop\Log_1000.txt""",
            };
            IList <string> actual = actualScripts;

            Assert.Equal(expected, actual);
        }