Example #1
0
        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            Task.Run(async () =>
            {
                bool isOpened = await this.tmp102.OpenAsync();

                IDictionary bag = new Dictionary<SensorType, float>();

                while (true)
                {
                    float temperature = tmp102.Temperature();
                    SensorType sensorType = SensorType.Temperature;

                    if (!bag.Contains(sensorType))
                        bag.Add(sensorType, temperature);
                    else
                        bag[sensorType] = temperature;

                    if ((this.iotClient != null) && (this.iotClient.IsOpen))
                    {
                        this.iotClient.SendAsync(bag);
                    }

                    await Task.Delay(5000);
                }
            });

        }
Example #2
0
        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            Task.Run(async () =>
            {
                IDictionary bag = new Dictionary<SensorType, float>();
                var rnd = new Random();

                while (true)
                {

                    var temperature = (float)GetRandomNumber(rnd, -10, 50);

                    SensorType sensorType = SensorType.Temperature;

                    if (!bag.Contains(sensorType))
                        bag.Add(sensorType, temperature);
                    else
                        bag[sensorType] = temperature;

                    if ((this.iotClient != null) && (this.iotClient.IsOpen))
                    {
                        this.iotClient.SendAsync(bag);
                    }

                    await Task.Delay(5000);
                }
            });
        }
Example #3
0
        public void WriterWriteEmptyString()
        {
            string outputPath = Guid.NewGuid().ToString() + ".plist";

            IDictionary dict = new Dictionary<string, object>();
            dict["Empty"] = string.Empty;

            BinaryPlistWriter writer = new BinaryPlistWriter();
            writer.WriteObject(outputPath, dict);

            BinaryPlistReader reader = new BinaryPlistReader();
            dict = reader.ReadObject(outputPath);

            Assert.IsTrue(dict.Contains("Empty"));
            Assert.AreEqual(string.Empty, dict["Empty"]);
        }
Example #4
0
        public async void Run(IBackgroundTaskInstance taskInstance)
        {
            // 
            // TODO: Insert code to start one or more asynchronous methods 
            //

            BackgroundTaskDeferral deferral = taskInstance.GetDeferral();

            this.tmp102 = new TMP102();

            // set and open the IoT client
            if (this.iotClient == null)
            {
                //this.iotClient = new IoTClient("raspberrypi2", Guid.NewGuid().ToString(), this.connectionString, this.eventHubEntity);
                this.iotClient = new IoTClientConnectTheDots("raspberrypi2", Guid.NewGuid().ToString(), this.connectionString, this.eventHubEntity);
            }

            if (!this.iotClient.IsOpen)
                this.iotClient.Open();


            bool isOpened = await this.tmp102.OpenAsync();
            
            IDictionary bag = new Dictionary<SensorType, float>();

            while (true)
            {
                float temperature = tmp102.Temperature();
                SensorType sensorType = SensorType.Temperature;

                if (!bag.Contains(sensorType))
                    bag.Add(sensorType, temperature);
                else
                    bag[sensorType] = temperature;

                if ((this.iotClient != null) && (this.iotClient.IsOpen))
                {
                    this.iotClient.SendAsync(bag);
                }

                await Task.Delay(5000);
            }

            deferral.Complete();
        }
Example #5
0
		public void IDictionary_Contains ()
		{
			IDictionary d = new Dictionary<int, int> ();
			d.Add (1, 2);
			Assert.IsTrue (d.Contains (1));
			Assert.IsFalse (d.Contains (2));
			Assert.IsFalse (d.Contains ("x"));
		}
Example #6
0
        /// <summary>
        /// Execute the MSBuild Task.
        /// </summary>
        /// <returns></returns>
        public override bool Execute()
        {
            _modifiedFiles = new ArrayList();
            _deletedFiles = new ArrayList();

            // Parse local manifest to retrieve list of files and their hashes.
            string[] localManifest = File.ReadAllLines(_localManifestFile);
            Dictionary<string, string> localFiles = new Dictionary<string,string>();
            for (int i = 0; i < localManifest.Length; i++)
            {
                if (localManifest[i].StartsWith("Archive-Asset-Name: "))
                {
                    string assetName = localManifest[i].Substring(20);
                    i++;
                    if (localManifest[i].StartsWith("Archive-Asset-SHA-512-Digest: "))
                    {
                        string assetHash = localManifest[i].Substring(30);
                        localFiles.Add(assetName, assetHash);
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            // Do the same for the target manifest.
            string[] targetManifest = File.ReadAllLines(_targetManifestFile);
            Dictionary<string, string> targetFiles = new Dictionary<string,string>();
            for (int i = 0; i < targetManifest.Length; i++)
            {
                if (targetManifest[i].StartsWith("Archive-Asset-Name: "))
                {
                    string assetName = targetManifest[i].Substring(20);
                    i++;
                    if (targetManifest[i].StartsWith("Archive-Asset-SHA-512-Digest: "))
                    {
                        string assetHash = targetManifest[i].Substring(30);
                        targetFiles.Add(assetName, assetHash);
                    }
                    else
                    {
                        return false;
                    }
                }
            }

            // Compare hashes and populate the lists of modified and deleted files.
            string[] targetFileMap = File.ReadAllLines(_targetFileMap);
            foreach (KeyValuePair<string, string> file in localFiles)
            {
                // For some reason this MANIFEST.bbr file appears in the manifest, even though
                // it doesn't actually exist anywhere...?  It doesn't seem to correspond to
                // MANIFEST.MF either.
                if (file.Key == "META-INF/MANIFEST.bbr")
                {
                    continue;
                }

                // If the target manifest doesn't contain the same key/value pair,
                // that means the local file has been either added or modified.
                if (!targetFiles.Contains(file))
                {
                    TaskItem item = new TaskItem(file.Key);
                    item.SetMetadata("SourcePath", getSourcePath(file.Key, targetFileMap));
                    _modifiedFiles.Add(item);
                }
            }

            IDictionaryEnumerator targetEnum = targetFiles.GetEnumerator();
            while (targetEnum.MoveNext())
            {
                // If the local manifest doesn't contain the same key,
                // that means the target file has been deleted from the project.
                if (!localFiles.ContainsKey((string)targetEnum.Key))
                {
                    TaskItem item = new TaskItem((string)targetEnum.Key);
                    _deletedFiles.Add(item);
                }
            }

            // For some reason the manifest file doesn't show up in the target file map
            // or the manifest itself, so we add it manually here and always upload it.
            TaskItem manifestItem = new TaskItem("META-INF/MANIFEST.MF");
            manifestItem.SetMetadata("SourcePath", "localManifest.mf");
            _modifiedFiles.Add(manifestItem);

            return true;
        }
    public void Contains_Enumerable_OnDictionary_IsTranslatedAsAContainsResultOperator ()
    {
      var dictionary = new Dictionary<string, int>();
      var query = from c in QuerySource
                  where dictionary.Contains (new KeyValuePair<string, int> (c.Name, c.ID))
                  select c;

      var queryModel = QueryParser.GetParsedQuery (query.Expression);

      var whereClause = (WhereClause) queryModel.BodyClauses.Single ();
      Assert.That (whereClause.Predicate, Is.InstanceOf<SubQueryExpression> ());

      var subQueryModel = ((SubQueryExpression) whereClause.Predicate).QueryModel;
      Assert.That (subQueryModel.ResultOperators, Has.Count.EqualTo (1));
      Assert.That (subQueryModel.ResultOperators.Single(), Is.TypeOf<ContainsResultOperator>());
    }
    public void Contains_IDictionary_IsNotTranslatedAsAContainsResultOperator ()
    {
      IDictionary dictionary = new Dictionary<string, int> ();
      var query = from c in QuerySource
                  where dictionary.Contains (c.Name)
                  select c;

      var queryModel = QueryParser.GetParsedQuery (query.Expression);

      var whereClause = (WhereClause) queryModel.BodyClauses.Single();
      Assert.That (whereClause.Predicate, Is.Not.InstanceOf<SubQueryExpression> ());
      Assert.That (whereClause.Predicate, Is.InstanceOf<MethodCallExpression> ());
    }
        public void ReadOnlyDictionary_Unit_GetEnumerator1_Optimal()
        {
            IDictionary<String, String> dictionary = new Dictionary<String, String>() {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
                { "Key3", "Value3" }
            };
            ReadOnlyDictionary<String, String> target = new ReadOnlyDictionary<String, String>(dictionary);

            using (IEnumerator<KeyValuePair<String, String>> actual = target.GetEnumerator()) {
                Int32 count = 0;
                while (actual.MoveNext()) {
                    count++;
                    Assert.IsTrue(dictionary.Contains(actual.Current));
                }
                Assert.AreEqual(dictionary.Count, count);
            }
        }
Example #10
0
        private void SendData()
        {
            Task.Run(() =>
            {
                IDictionary bag = new Dictionary<SensorType, float>();

                var rate = (float)currentRate;

                SensorType sensorType = SensorType.Temperature;

                if (!bag.Contains(sensorType))
                    bag.Add(sensorType, rate);
                else
                    bag[sensorType] = rate;

                if ((this.iotClient != null) && (this.iotClient.IsOpen))
                {
                    this.iotClient.SendAsync(bag);
                }
            });
        }
        public void ShouldLog_IfExceptionDataContainsLoggedByOfIncompatibleType_ReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            IDictionary data = new Dictionary();
            data.Add(ExceptionLogger.LoggedByKey, null);
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.Equal(true, shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object updatedLoggedBy = data[ExceptionLogger.LoggedByKey];
            Assert.Null(updatedLoggedBy);
        }
        public void ShouldLog_IfExceptionDataContainsLoggedByLogger_ReturnsFalse()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            IDictionary data = new Dictionary();
            ICollection<object> loggedBy = new List<object>() { product };
            data.Add(ExceptionLogger.LoggedByKey, loggedBy);
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.Equal(false, shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object updatedLoggedBy = data[ExceptionLogger.LoggedByKey];
            Assert.Same(loggedBy, updatedLoggedBy);
            Assert.Equal(1, loggedBy.Count);
        }
        public void ShouldLog_IfExceptionDataIsEmpty_AddsLoggedByKeyWithLoggerValueAndReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            IDictionary data = new Dictionary();
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.Equal(true, shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object loggedBy = data[ExceptionLogger.LoggedByKey];
            Assert.IsAssignableFrom<ICollection<object>>(loggedBy);
            Assert.Contains(product, (ICollection<object>)loggedBy);
        }
Example #14
0
        public void NonNullDictionary_Unit_GetEnumerator3_Optimal()
        {
            IDictionary<String, String> dictionary = new Dictionary<String, String>() {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
                { "Key3", "Value3" }
            };
            IEnumerable target = new NonNullDictionary<String, String>(dictionary);

            IEnumerator actual = target.GetEnumerator();
            Int32 count = 0;
            while (actual.MoveNext()) {
                count++;
                Assert.IsTrue(dictionary.Contains((KeyValuePair<String, String>)actual.Current));
            }
            Assert.AreEqual(dictionary.Count, count);
        }
Example #15
0
        public void NonNullDictionary_Unit_CopyTo_Optimal()
        {
            IDictionary<String, String> dictionary = new Dictionary<String, String>() {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
                { "Key3", "Value3" }
            };
            ICollection<KeyValuePair<String, String>> target = new NonNullDictionary<String, String>(dictionary);
            KeyValuePair<String, String>[] array = new KeyValuePair<String, String>[dictionary.Count];
            Int32 arrayIndex = 0;

            target.CopyTo(array, arrayIndex);
            Assert.AreEqual(dictionary.Count, array.Length);
            foreach (KeyValuePair<String, String> pair in array) {
                Assert.IsTrue(dictionary.Contains(pair));
            }
        }
Example #16
0
		public void IDictionary_Contains2 ()
		{
			IDictionary d = new Dictionary<int, int> ();
			d.Contains (null);
		}
        public void Contains()
        {
            IDictionary<string, string> dict = new Dictionary<string, string>();
            dict.Add("Key", "Value");
            dict.Add("OtherKey", "OtherValue");

            dict = dict.ToReadOnlyDictionary();

            Assert.IsTrue(dict.Contains(KeyValuePair.Create("Key", "Value")));
            Assert.IsTrue(dict.Contains(KeyValuePair.Create("OtherKey", "OtherValue")));

            Assert.IsFalse(dict.Contains(KeyValuePair.Create("NonExistent", "NonExistentValue")));
        }
Example #18
0
        static void ReplaceVars(ref string value, bool pVerbose)
        {
            if (pVerbose)
                WriteLine("Variables detected! Running parser...");

            // Get the variables such as %USERNAME%, $HOME, etc.
            MatchCollection Results =
                Regex.Matches(value, @"(\$\w+)|(%\w+%)", RegexOptions.ECMAScript);

            // A dictionary of environment variables, please note that user variables
            // are acted upon first. Proof: Type in "set" in a cmd session.
            IDictionary envs =
                new Dictionary<string, string>(128, StringComparer.OrdinalIgnoreCase);

            string userprofile = GetFolderPath(SpecialFolder.UserProfile);

            /*************************
             * Linux common examples *
             *************************
                HOME=/home/dd
                HOSTNAME=dd-vm
                HOSTTYPE=x86_64
                PWD=/home/dd/Desktop
                SHELL=/bin/bash
                UID=1000
                USER=dd
               *USERNAME=dd
               
               *Already in Windows.
             */
            envs.Add("HOME", userprofile);
            envs.Add("HOSTNAME", MachineName);
            envs.Add("HOSTTYPE", Is64BitOperatingSystem ? "x86_64" : "i686");
            envs.Add("USER", UserName);
            envs.Add("PWD", GetFolderPath(SpecialFolder.Desktop));

            /**
             * Windows auto-generated variables
             * TMP and TEMP are already user variables.
             */
            envs.Add("SYSTEMROOT", Path.GetDirectoryName(SystemDirectory)); // C:\Windows
            envs.Add("SYSTEMDRIVE", Path.GetPathRoot(SystemDirectory)); // C:\

            // <HKEY_CURRENT_USER\Volatile> Variables
            envs.Add("APPDATA", [email protected]"{userprofile}\AppData\Roaming");
            envs.Add("HOMEDRIVE", Path.GetPathRoot(userprofile).Replace("\\", "")); // C:
            envs.Add("HOMEPATH", userprofile.Replace(envs["HOMEDRIVE"].ToString(), "")); // \Users\DD
            envs.Add("LOCALAPPDATA", [email protected]"{userprofile}\AppData\Local");
            envs.Add("LOGONSERVER", [email protected]"\\{UserDomainName}"); // Unsure
            envs.Add("USERDOMAIN", UserDomainName);
            envs.Add("USERDOMAIN_ROAMINGPROFILE", UserDomainName); // Unsure
            envs.Add("USERPROFILE", userprofile);
            //envs.Add("", "");

            foreach (DictionaryEntry i in
                GetEnvironmentVariables(EnvironmentVariableTarget.User))
                if (!envs.Contains(i.Key))
                    envs.Add(i.Key, i.Value);

            foreach (DictionaryEntry i in
                GetEnvironmentVariables(EnvironmentVariableTarget.Machine))
                if (!envs.Contains(i.Key))
                    envs.Add(i.Key, i.Value);
            
            foreach (Match result in Results)
            {
                string t = result.Value.StartsWith("$") ?
                    result.Value.TrimStart('$') :
                    result.Value.Trim('%');

                if (envs.Contains(t))
                {
                    if (pVerbose)
                        WriteLine($"Variable: {result.Value} -> {envs[t]}");

                    value =
                        value.Replace(result.Value, envs[t].ToString());
                }
                else if (pVerbose)
                    WriteLine($"ENV NOT FOUND: {t}");
            }
        }