GetRange() public method

public GetRange ( int index, int count ) : ArrayList
index int
count int
return ArrayList
Example #1
0
        public void Test(int arg)
        {
            ArrayList items = new ArrayList();
            items.Add(1);
            items.AddRange(1, 2, 3);
            items.Clear();
            bool b1 = items.Contains(2);
            items.Insert(0, 1);
            items.InsertRange(1, 0, 5);
            items.RemoveAt(4);
            items.RemoveRange(4, 3);
            items.Remove(1);
            object[] newItems = items.GetRange(5, 2);
            object[] newItems2 = items.GetRange(5, arg);

            List<int> numbers = new List<int>();
            numbers.Add(1);
            numbers.AddRange(1, 2, 3);
            numbers.Clear();
            bool b2 = numbers.Contains(4);
            numbers.Insert(1, 10);
            numbers.InsertRange(2, 10, 3);
            numbers.RemoveAt(4);
            numbers.RemoveRange(4, 2);
            int[] newNumbers = items.GetRange(5, 2);
            int[] newNumbers2 = items.GetRange(5, arg);

            string[] words = new string[5];
            words[0] = "hello";
            words[1] = "world";
            bool b3 = words.Contains("hi");
            string[] newWords = words.GetRange(5, 2);
            string[] newWords2 = words.GetRange(5, arg);
        }
Example #2
0
        public ArrayList Sort(ArrayList inArray)
        {
            if (1 == inArray.Count)
                return inArray;

            int middle = inArray.Count >> 1;
            ArrayList left = Sort(inArray.GetRange(0, middle));
            ArrayList right = Sort(inArray.GetRange(middle, inArray.Count - middle));
            return Merge(left, right);
        }
Example #3
0
        private string Breaker(ArrayList Cell_String)
        {
            for (int i = 1; i < Cell_String.Count; i++)
            {
                if (Fun_Class.IsFunction(Cell_String[i].ToString()))
                {
                    int found = 1;
                    int start = i + 1;

                    while (found != 0)
                    {
                        start++;
                        if (Cell_String[start].ToString().Equals("("))
                            found++;
                        if (Cell_String[start].ToString().Equals(")"))
                            found--;
                    }
                    ArrayList atemp = new ArrayList(Cell_String.GetRange(i, start - i + 1));
                    Cell_String.RemoveRange(i, start - i + 1);
                    Cell_String.Insert(i, Breaker(atemp));
                }
            }

            //PrintArrayList(Cell_String);
            //System.Console.WriteLine(Cell_String[0].ToString());

            return Fun_Class.CallFunction(Cell_String);
        }
Example #4
0
        public void TestGetItems()
        {
            //--------------------------------------------------------------------------
            // Variable definitions.
            //--------------------------------------------------------------------------
            ArrayList arrList = null;
            //
            // Construct array list.
            //
            arrList = new ArrayList();

            // Add items to the lists.
            for (int ii = 0; ii < strHeroes.Length; ++ii)
            {
                arrList.Add(strHeroes[ii]);
            }

            // Verify items added to list.
            Assert.Equal(strHeroes.Length, arrList.Count);

            //Adapter, GetRange, Synchronized, ReadOnly returns a slightly different version of 
            //BinarySearch, Following variable cotains each one of these types of array lists

            ArrayList[] arrayListTypes = {
                                        (ArrayList)arrList.Clone(),
                                        (ArrayList)ArrayList.Adapter(arrList).Clone(),
                                        (ArrayList)ArrayList.FixedSize(arrList).Clone(),
                                        (ArrayList)ArrayList.ReadOnly(arrList).Clone(),
                                        (ArrayList)arrList.GetRange(0, arrList.Count).Clone(),
                                        (ArrayList)ArrayList.Synchronized(arrList).Clone()};

            foreach (ArrayList arrayListType in arrayListTypes)
            {
                arrList = arrayListType;
                //
                // []  Verify get method.
                //
                // Search and verify selected items.
                for (int ii = 0; ii < strHeroes.Length; ++ii)
                {
                    // Verify get.
                    Assert.Equal(0, ((string)arrList[ii]).CompareTo(strHeroes[ii]));
                }

                //
                // []  Invalid Index.
                //
                Assert.Throws<ArgumentOutOfRangeException>(() =>
                {
                    string str = (string)arrList[(int)arrList.Count];
                });

                Assert.Throws<ArgumentOutOfRangeException>(() =>
                {
                    string str = (string)arrList[-1];
                });
            }
        }
Example #5
0
        public override ArrayList select(ArrayList gens)
        {
            int nr;

            if (gens.Count >= this._newPopSize)
                nr = (int)(gens.Count * this._newPopSize);
            else
                nr = 1;

            gens.Sort((IComparer)new GenomeComparer());

            return gens.GetRange(0, nr);
        }
        public ArrayList Recombine(ArrayList maleGenes, ArrayList femaleGenes)
        {
            double maleConstraint = random.NextDouble();
            int maleCount = (int)Math.Ceiling(maleGenes.Count * maleConstraint);
            int femaleCount = (int)Math.Floor(femaleGenes.Count * (1-maleConstraint));
            ArrayList child = new ArrayList(maleCount + femaleCount);
            child.InsertRange(0, maleGenes.GetRange(0, maleCount));
            child.InsertRange(maleCount, femaleGenes.GetRange(femaleGenes.Count - femaleCount, femaleCount));

            for (int i = 0; i < child.Count; i++)
                child[i] = (child[i] as IGene).Clone();

            return child;
        }
        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();
            al.Add("Paris");
            al.Add("Ottowa");
            al.AddRange(new string[] { "Rome", "Tokyo", "Tunis", "Canberra" });

            Console.WriteLine("Count:    {0}", al.Count);
            Console.WriteLine("Capacity: {0}", al.Capacity);

            Console.WriteLine("Print values using foreach");
            PrintValues(al);
            Console.WriteLine("Print values using IEnumerator");
            PrintValuesByEnumerator(al);

            // Get second item in list as string
            string str = (string)al[1];    // need to cast, would also unbox if stored type was value type
            Console.WriteLine("al[1] = {0}", str);

            // Get first three items
            ArrayList firstThree = al.GetRange(0, 3);
            PrintValues(firstThree);

            // Remove next two
            al.RemoveRange(3, 2);
            PrintValues(al);

            // Get, insert and remove
            object itemOne = al[1];
            al.Insert(1, "Moscow");
            al.RemoveAt(2);
            PrintValues(al);

            // Sort
            al.Sort();
            PrintValues(al);

            // Search
            int targetIndex = al.BinarySearch("Moscow");
            Console.WriteLine("Index of Moscow: {0}", targetIndex);

            // Trim capacity
            al.TrimToSize();
            Console.WriteLine("Count:    {0}", al.Count);
            Console.WriteLine("Capacity: {0}", al.Capacity);

            // Creates a new ArrayList with five elements and initialize each element with a value.
            ArrayList al2 = ArrayList.Repeat("Boston", 5);   // static method
            PrintValues(al2);
        }
Example #8
0
        /// <summary>
        /// Joins a new string with the elements of the array.
        /// </summary>
        /// <param name="joiner">The joiner.</param>
        /// <param name="joinees">The joinees.</param>
        /// <returns>The combined string.</returns>
        public static string Join(string joiner, ArrayList joinees)
        {
            if (joinees.Count == 0)
            {
                return string.Empty;
            }

            string joined = (string)joinees[0];
            foreach (string str in joinees.GetRange(1, joinees.Count - 1))
            {
                joined = joined + joiner + str;
            }

            return joined;
        }
        public ArrayList Recombine(ArrayList maleGenes, ArrayList femaleGenes)
        {
            if (maleGenes.Count != femaleGenes.Count)
                throw new GenesIncompatibleException();
            ArrayList child = new ArrayList(maleGenes.Count);
            int middle = maleGenes.Count / 2;
            child.InsertRange(0, maleGenes.GetRange(0, middle).Clone() as ArrayList);
            child.InsertRange(middle, femaleGenes.GetRange(middle, femaleGenes.Count - middle).Clone() as ArrayList);

            // Create Deep Copy
            for (int i = 0; i < child.Count; i++)
                child[i] = (child[i] as IGene).Clone();

            return child;
        }
Example #10
0
        private void addToListBox(ArrayList list)
        {
            try
            {
                int rango = list.Count - posListBox * 10;
                if (rango > 10)
                    rango = 10;
                foreach (Frases item in list.GetRange(posListBox * 10, rango))
                {
                    lbFrases.Items.Add(item.Autor + ": \t" + item.Frase);
                }
            }
            catch { }


        }
Example #11
0
        public static ArrayList Merge(ArrayList left, ArrayList right)
        {
            var result = new ArrayList();
            int leftptr=0, rightptr=0;

            while (leftptr < left.Count && rightptr < right.Count)
                result.Add((int) left[leftptr] < (int) right[rightptr] ? left[leftptr++] : right[rightptr++]);

            if (leftptr < left.Count)
                result.AddRange(left.GetRange(leftptr, left.Count - leftptr));

            if (rightptr < right.Count)
                result.AddRange(right.GetRange(rightptr, right.Count - rightptr));

            return result;
        }
Example #12
0
        static void Main(string[] args)
        {
            //Create an ArrayList and add two ints
            ArrayList list = new ArrayList();
            list.Add("bird");
            list.Add("rock");
            list.Add("jacket");
            list.Add("shoe");

            // Get Last two elements in ArrayList
            ArrayList range = list.GetRange(2, 2);
            //Display Elements
            foreach (string value in range)
            {
                Console.WriteLine(value); // jacket, shoe

            }
        }
Example #13
0
        public void TestArrayListWrappers()
        {
            ArrayList alst1;
            string strValue;
            Array arr1;

            //[] Vanila test case - ToArray returns an array of this. We will not extensively test this method as
            // this is a thin wrapper on Array.Copy which is extensively tested elsewhere
            alst1 = new ArrayList();
            for (int i = 0; i < 10; i++)
            {
                strValue = "String_" + i;
                alst1.Add(strValue);
            }

            ArrayList[] arrayListTypes = {
                                            alst1,
                                            ArrayList.Adapter(alst1),
                                            ArrayList.FixedSize(alst1),
                                            alst1.GetRange(0, alst1.Count),
                                            ArrayList.ReadOnly(alst1),
                                            ArrayList.Synchronized(alst1)};

            foreach (ArrayList arrayListType in arrayListTypes)
            {
                alst1 = arrayListType;
                arr1 = alst1.ToArray(typeof(string));

                for (int i = 0; i < 10; i++)
                {
                    strValue = "String_" + i;
                    Assert.Equal(strValue, (string)arr1.GetValue(i));
                }

                //[] this should be covered in Array.Copy, but lets do it for
                Assert.Throws<InvalidCastException>(() => { arr1 = alst1.ToArray(typeof(int)); });
                Assert.Throws<ArgumentNullException>(() => { arr1 = alst1.ToArray(null); });
            }

            //[]lets try an empty list
            alst1.Clear();
            arr1 = alst1.ToArray(typeof(Object));
            Assert.Equal(0, arr1.Length);
        }
Example #14
0
        public static AESInfo Destruct(String message, String privateKey)
        {
            int ebs = RSAKeySize/8;

            AESInfo result = new AESInfo();

            ArrayList bytes = new ArrayList(Convert.FromBase64String(StripMessage(message)));

            byte[] keyPart = (byte[]) bytes.GetRange(0, ebs).ToArray(Type.GetType("System.Byte"));

            result.key = RSADecrypt(keyPart, privateKey);
            result.IV = RSADecrypt((byte[]) bytes.GetRange(ebs, ebs).ToArray(Type.GetType("System.Byte")), privateKey);
            result.message = (byte[]) bytes.GetRange(ebs*2, bytes.Count - ebs*2).ToArray(Type.GetType("System.Byte"));

            return result;
        }
Example #15
0
 private void GetTrainPersonImages(string trainPersonName)
 {
     string strFile = m_rootPath + trainPersonName+"\\info.txt";
     try
     {
         if (File.Exists(strFile))
         {
             using (StreamReader sr = new StreamReader(strFile, Encoding.GetEncoding("gb2312")))
             {
                 ArrayList str_list = new ArrayList();
                 while (sr.Peek() >= 0)
                 {
                     string str = sr.ReadLine();
                     str = m_rootPath + trainPersonName + "\\"+str;
                     str_list.Add(str);
                 }
                 int count = str_list.Count;
                 m_trainPersonImagesInfo = str_list.GetRange(3, count - 3);
             }
         }
     }
     catch (System.Exception ex)
     {
         MessageBox.Show(ex.Message);
     }
 }
Example #16
0
 private void GetNameList()
 {
     string strFile = m_rootPath + "Record.txt";
     try
     {
         if (File.Exists(strFile))
         {
             using (StreamReader sr = new StreamReader(strFile,Encoding.GetEncoding("gb2312")))
             {
                 ArrayList str_list = new ArrayList();
                 while (sr.Peek() >= 0)
                 {
                     string str = sr.ReadLine();
                     str_list.Add(str);                            
                 }
                 int count=str_list.Count;
                 m_nameList = str_list.GetRange(3, count - 3);
             }
         }
     }
     catch (System.Exception ex)
     {
         MessageBox.Show(ex.Message);
     }
 }
Example #17
0
		public void GetRange_CountOverflow ()
		{
			ArrayList al = new ArrayList ();
			al.Add (this);
			al.GetRange (0, Int32.MaxValue);
		}
Example #18
0
        /*
         * PBKDF2 as described in PKCS #5 v2.0 pp.8-10
         */
        private static byte[] PBKDF2(byte[] passphrase, byte[] salt, int c, int dkLen)
        {
            const int hLen = 20;
            int l = (int) Math.Ceiling((double) dkLen/hLen);
            //int r = dkLen - (l - 1)*hLen;

            ArrayList result = new ArrayList(dkLen);

            for (int i = 0; i < l; i++)
            {
                result.AddRange(F(passphrase, salt, c, i));
            }

            return (byte[]) result.GetRange(0, dkLen).ToArray(Type.GetType("System.Byte"));
        }
Example #19
0
        public void TestArrayListWrappers()
        {
            //--------------------------------------------------------------------------
            // Variable definitions.
            //--------------------------------------------------------------------------
            ArrayList arrList = null;
            int start = 3;
            int count = 15;

            string[] strHeroes =
            {
                "Aquaman",
                "Atom",
                "Batman",
                "Black Canary",
                "Captain America",
                "Captain Atom",
                "Catwoman",
                "Cyborg",
                "Flash",
                "Green Arrow",
                "Green Lantern",
                "Hawkman",
                "Huntress",
                "Ironman",
                "Nightwing",
                "Robin",
                "SpiderMan",
                "Steel",
                "Superman",
                "Thor",
                "Wildcat",
                "Wonder Woman",
            };

            string[] strResult =
            {
                "Aquaman",
                "Atom",
                "Batman",
                "Superman",
                "Thor",
                "Wildcat",
                "Wonder Woman",
            };

            //
            // Construct array list.
            //
            // Construct ArrayList.
            arrList = new ArrayList((ICollection)strHeroes);

            //Adapter, GetRange, Synchronized, ReadOnly returns a slightly different version of 
            //BinarySearch, Following variable cotains each one of these types of array lists

            ArrayList[] arrayListTypes = {
                                    (ArrayList)arrList.Clone(),
                                    (ArrayList)ArrayList.Adapter(arrList).Clone(),
                                    (ArrayList)arrList.GetRange(0, arrList.Count).Clone(),
                                    (ArrayList)ArrayList.Synchronized(arrList).Clone()};

            foreach (ArrayList arrayListType in arrayListTypes)
            {
                arrList = arrayListType;

                //
                // []  Remove objects from the ArrayList.
                //
                for (int ii = 0; ii < count; ++ii)
                {
                    arrList.RemoveAt(start);
                }

                // Verify the items in the array.
                for (int ii = 0; ii < strResult.Length; ++ii)
                {
                    Assert.Equal(0, strResult[ii].CompareTo((string)arrList[ii]));
                }

                //
                // []  Attempt invalid remove using negative index
                //
                Assert.Throws<ArgumentOutOfRangeException>(() => arrList.RemoveAt(-100));

                //
                //  []  Attempt remove using out of range index
                //
                Assert.Throws<ArgumentOutOfRangeException>(() => arrList.RemoveAt(1000));
            }
        }
        protected override void computeMACInfo()
        {
            if (m_viewStateBase64 == "")
            {
                return;
            }

            // this whole set of steps is a little cludgly, but there doesn't seem to be a better way for now.  We detect MAC info by
            // getting comparing the size of the original viewstate base64 decoded and the original viewstate decoded and then reencoded.  If the two objects
            // don't match in size and the difference between before and after is 20 bytes we assume there is MAC protection.
            byte[] originalViewStateDeserialized = System.Convert.FromBase64String(m_viewStateBase64);
            int arrowCount = 0;
            int i = 0;
            for(i = 0; i < originalViewStateDeserialized.Length; i++)
            {
                if (originalViewStateDeserialized[i] == (byte)'<')
                    arrowCount++;
                else if (originalViewStateDeserialized[i] == (byte)'>')
                    arrowCount--;
                else
                    continue;
                // if we find the closing ">" then we assume we are either at the end of the viewstate or their is trailing MAC info
                if (arrowCount == 0)
                {
                    i++; // we bump the counter up to skip past the final ">"
                    break;
                }

            }
            // if we have 20 bytes left we assume there is MAC protection
            if (originalViewStateDeserialized.Length - i == 20)
            {
                m_MACProtected = true;
                ArrayList tempList = new ArrayList(originalViewStateDeserialized);
                byte[] tempArray = new byte[20];  //the size of the MAC
                int MACIndex = originalViewStateDeserialized.Length - 20; // 20 is the size of the MAC
                tempList.GetRange(MACIndex, 20).CopyTo(tempArray);
                String hexString = BitConverter.ToString(tempArray);
                m_MAC = hexString.Replace("-", "");
            } else
            {
                m_MACProtected = false;

            }
        }
Example #21
0
        public void TestSetItems()
        {
            //--------------------------------------------------------------------------
            // Variable definitions.
            //--------------------------------------------------------------------------
            ArrayList arrList = null;

            //
            // Construct array list.
            //
            arrList = new ArrayList((ICollection)strHeroes);

            //Adapter, GetRange, Synchronized, ReadOnly returns a slightly different version of 
            //BinarySearch, Following variable cotains each one of these types of array lists

            ArrayList[] arrayListTypes = {
                                    (ArrayList)arrList.Clone(),
                                    (ArrayList)ArrayList.Adapter(arrList).Clone(),
                                    (ArrayList)ArrayList.FixedSize(arrList).Clone(),
                                    (ArrayList)arrList.GetRange(0, arrList.Count).Clone(),
                                    (ArrayList)ArrayList.Synchronized(arrList).Clone()};

            foreach (ArrayList arrayListType in arrayListTypes)
            {
                arrList = arrayListType;

                //
                // []  Set item in the array list.
                //
                arrList[0] = "Lone Ranger";

                // Verify set.
                Assert.Equal(0, ((string)arrList[0]).CompareTo("Lone Ranger"));

                //
                // []  Attempt invalid Set using negative index
                //
                Assert.Throws<ArgumentOutOfRangeException>(() => { arrList[-100] = "Lone Ranger"; });

                //
                //  []  Attempt Set using out of range index=1000
                //
                Assert.Throws<ArgumentOutOfRangeException>(() => { arrList[1000] = "Lone Ranger"; });

                //
                //  []  Attempt Set using out of range index=-1
                //
                Assert.Throws<ArgumentOutOfRangeException>(() => { arrList[-1] = "Lone Ranger"; });

                //
                //  []  Attempt Set using null value.
                //
                arrList[0] = null;
                // Verify set.
                Assert.Null(arrList[0]);
            }
        }
Example #22
0
        private int FinalizeUpdate(String filename, String passphrase)
        {
            try
            {
                core.InitializeKeys(passphrase);
            }
            catch
            {
                Console.Error.WriteLine("Invalid passphrase");
                return 1;
            }

            StreamReader sr = new StreamReader(Path.Combine(core.ApplicationDataFolder, "identity"));
            String username = sr.ReadLine();
            String email = sr.ReadLine();
            sr.Close();

            username.Trim();
            email.Trim();

            Connect();

            ArrayList key = new ArrayList(File.ReadAllBytes(Path.Combine(core.ApplicationDataFolder, "answers.key")));
            AESInfo info = new AESInfo();
            info.key = (byte[]) key.GetRange(0, Crypto.AESKeySize/8).ToArray(Type.GetType("System.Byte"));
            info.IV =
                (byte[]) key.GetRange(Crypto.AESKeySize/8, Crypto.AESIVSize/8).ToArray(Type.GetType("System.Byte"));

            Rijndael aes = Rijndael.Create();

            String e_macpass = File.ReadAllText(filename);
            e_macpass = Crypto.StripMessage(e_macpass);

            byte[] macpass =
                Crypto.AESDecrypt(Convert.FromBase64String(e_macpass), aes.CreateDecryptor(info.key, info.IV));

            HMAC hmac = HMACSHA1.Create();
            hmac.Key = macpass;
            byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(core.PublicKey));

            if (server.USKeyUpdate_SendPublicKey(username, email, core.PublicKey, Convert.ToBase64String(hash)))
            {
                Console.WriteLine("Public key successfully sent.");
            }
            else
            {
                Console.WriteLine("Public key could not be sent, please try again.");
            }

            File.Delete(Path.Combine(core.ApplicationDataFolder, "answers.key"));

            return 0;
        }
		private void PrivateTestGetRange(ArrayList arrayList) 
		{
			ArrayList rangeList;

			arrayList.AddRange(c_TestData);

			rangeList = arrayList.GetRange(3, 5);

			Assert.IsTrue(rangeList.Count == 5, "rangeList.Count == 5");

			this.VerifyContains(rangeList, new object[] {3,4,5,6,7}, "1: VerifyContains(rangeList)");
			
//FIXME: If items are removed from the Range, one may not iterate over it on .NET
/*
			rangeList.Remove(7);
			
			this.VerifyContains(a2, new object[] {3,4,5,6}, "2: VerifyContains(rangeList)");

			rangeList.RemoveAt(0);

			this.VerifyContains(a3, new object[] {4,5,6}, "3: VerifyContains(rangeList)");

			rangeList.Add(7);
			rangeList.Add(6);
			rangeList.Add(3);
			rangeList.Add(11);
			
			Assert.IsTrue(rangeList.LastIndexOf(6) == 4, "rangeList.LastIndexOf(6) == 4");

			rangeList.Sort();

			this.VerifyContains(arrayList, new object[] {0, 1, 2, 3, 4, 5, 6, 6, 7, 11, 8, 9}, "4: VerifyContains(rangeList)");
*/
		}
Example #24
0
        public static byte[] RAWDecrypt(byte[] cipherText, String privateKey)
        {
            int ebs = RSAKeySize/8;
            Rijndael aes = Rijndael.Create();
            ArrayList bytes = new ArrayList(cipherText);
            byte[] keyPart = (byte[]) bytes.GetRange(0, ebs).ToArray(Type.GetType("System.Byte"));

            byte[] key = RSADecrypt(keyPart, privateKey);
            byte[] IV = RSADecrypt((byte[]) bytes.GetRange(ebs, ebs).ToArray(Type.GetType("System.Byte")), privateKey);
            byte[] message = (byte[]) bytes.GetRange(ebs*2, bytes.Count - ebs*2).ToArray(Type.GetType("System.Byte"));

            return AESDecrypt(message, aes.CreateDecryptor(key, IV));
        }
Example #25
0
        private static AESInfo DeriveKeyAndIV(String passphrase, byte[] salt, int keyLen, int IVLen)
        {
            const int saltLength = 8;
            int k = keyLen/8;
            int i = IVLen/8;

            AESInfo result = new AESInfo();

            byte[] passphraseBytes = Encoding.UTF8.GetBytes(passphrase);

            if (salt == null)
            {
                result.salt = new byte[saltLength];
                Random random = new Random();
                random.NextBytes(result.salt);
            }
            else
            {
                result.salt = salt;
            }

            ArrayList keyAndIV = new ArrayList(k + i);
            keyAndIV.AddRange(PBKDF2(passphraseBytes, result.salt, 10000, k + i));

            result.key = (byte[]) keyAndIV.GetRange(0, k).ToArray(Type.GetType("System.Byte"));
            result.IV = (byte[]) keyAndIV.GetRange(k, i).ToArray(Type.GetType("System.Byte"));

            return result;
        }
Example #26
0
		public void TestGetRange ()
		{
			{
				bool errorThrown = false;
				try {
					ArrayList a = new ArrayList ();
					ArrayList b = a.GetRange (-1, 1);
				} catch (ArgumentOutOfRangeException) {
					errorThrown = true;
				}
				Assert.IsTrue (errorThrown, "negative index error not thrown");
			}
			{
				bool errorThrown = false;
				try {
					ArrayList a = new ArrayList ();
					ArrayList b = a.GetRange (1, -1);
				} catch (ArgumentOutOfRangeException) {
					errorThrown = true;
				}
				Assert.IsTrue (errorThrown, "negative index error not thrown");
			}
			{
				bool errorThrown = false;
				try {
					ArrayList a = new ArrayList ();
					ArrayList b = a.GetRange (1, 1);
				} catch (ArgumentException) {
					errorThrown = true;
				}
				Assert.IsTrue (errorThrown, "out-of-range index error not thrown");
			}
			{
				char [] chars = { 'a', 'b', 'c', 'd', 'e', 'f' };
				ArrayList a = new ArrayList (chars);
				ArrayList b = a.GetRange (1, 3);
				Assert.AreEqual (3, b.Count, "GetRange returned wrong size ArrayList");
				for (int i = 0; i < b.Count; i++) {
					Assert.AreEqual (chars [i + 1], b [i], "range didn't work");
				}

				a [2] = '?'; // should screw up ArrayList b.
				bool errorThrown = false;
				try {
					int i = b.Count;
				} catch (InvalidOperationException) {
					errorThrown = true;
				}
				Assert.AreEqual (true, errorThrown, "Munging 'a' should mess up 'b'");
			}
			{
				char [] chars = { 'a', 'b', 'c', 'd', 'e', 'f' };
				ArrayList a = new ArrayList (chars);
				ArrayList b = a.GetRange (3, 3);
				object [] obj_chars = b.ToArray ();
				for (int i = 0; i < 3; i++) {
					char c = (char) obj_chars [i];
					Assert.AreEqual (chars [i + 3], c, "range.ToArray didn't work");
				}
				char [] new_chars = (char []) b.ToArray (typeof (char));
				for (int i = 0; i < 3; i++) {
					Assert.AreEqual (chars [i + 3], new_chars [i], "range.ToArray with type didn't work");
				}
			}
		}
 private String getViewStateStringWithoutMAC()
 {
     int offset = 0;
     if (m_MACProtected)
     {
         offset = 20;
     }
     ArrayList tempList = new ArrayList(System.Convert.FromBase64String(m_viewStateBase64));
     byte[] tempArray = new byte[tempList.Count - offset];  //the size of the MAC
     tempList.GetRange(0, tempList.Count - offset).CopyTo(tempArray);
     return System.Text.Encoding.UTF8.GetString(tempArray);
 }
Example #28
0
		public void GetRange_IndexOverflow ()
		{
			ArrayList al = new ArrayList ();
			al.Add (this);
			al.GetRange (Int32.MaxValue, 0);
		}
Example #29
0
        /* NOT COMPLETE YET (Cell Reference,A1) 
         * THIS NEED TO BE SOLVED BY UI! 
         * The UI team needs to setup a mathod that takes a Cell Reference as a string and return the formula.
         */
        private ArrayList Reformat(ArrayList Parts)
        {
            #region SECTION REMOVER ()
            for (int i = 0; i < Parts.Count; i++)
            {
                int second = i - 1;
                if (second == -1)
                    second = 0;
                if (Parts[i].ToString().Equals("(") && !Fun_Class.IsFunction(Parts[second].ToString()) && !IsNumber(Parts[second].ToString()))
                {
                    //PrintArrayList(Parts);

                    int found = 1;
                    int start = i;

                    while (found != 0)
                    {
                        start++;
                        if (Parts[start].ToString().Equals("("))
                            found++;
                        if (Parts[start].ToString().Equals(")"))
                            found--;
                    }
                    ArrayList atemp = new ArrayList(Parts.GetRange(i + 1, start - i + 1 - 2));
                    Parts.RemoveRange(i, start - i + 1);
                    Parts.InsertRange(i, Reformat(atemp));
                }
            }
            #endregion
            #region SHORTCUT REMOVER * and /
            for (int i = 0; i < Parts.Count; i++)
            {
                string function;
                if (Parts[i].ToString().Equals("*") || Parts[i].ToString().Equals("/"))
                {
                    //PrintArrayList(Parts);

                    if (Parts[i].ToString().Equals("*"))
                        function = "MUL";
                    else
                        function = "DIV";

                    try
                    {
                        int first = i - 1, second = i + 2;
                        if ((i + 2) >= Parts.Count)
                            second--;
                        if (Parts[first].ToString().Equals(")") && !Parts[second].ToString().Equals("("))
                        {
                            int found = 1;
                            int start = i - 1;

                            while (found != 0)
                            {
                                start--;
                                if (Parts[start].ToString().Equals(")"))
                                    found++;
                                if (Parts[start].ToString().Equals("("))
                                    found--;
                            }

                            Parts.Insert(i, ")");
                            Parts.Insert(i, Parts[i + 2]);
                            Parts.Insert(i, ",");
                            Parts.InsertRange(i, Parts.GetRange(start - 1, i - start + 1));
                            Parts.Insert(i, "(");
                            Parts.Insert(i, function);

                            Parts.RemoveAt(i + (i - start + 1) + 5);
                            Parts.RemoveAt(i + (i - start + 1) + 5);
                            Parts.RemoveRange(start - 1, i - start + 1);
                        }
                        else
                        {
                            if (!Parts[first].ToString().Equals(")") && Parts[second].ToString().Equals("("))
                            {
                                int found = 1;
                                int start = i + 2;

                                while (found != 0)
                                {
                                    start++;
                                    if (Parts[start].ToString().Equals("("))
                                        found++;
                                    if (Parts[start].ToString().Equals(")"))
                                        found--;
                                }

                                Parts.Insert(start + i, ")");
                                Parts.Insert(i + 1, ",");
                                Parts.Insert(i + 1, Parts[i - 1]);
                                Parts.Insert(i + 1, "(");
                                Parts.Insert(i + 1, function);

                                Parts.RemoveAt(i - 1);
                                Parts.RemoveAt(i - 1);
                            }
                            else
                            {
                                if (!Parts[first].ToString().Equals(")") && !Parts[second].ToString().Equals("("))
                                {
                                    Parts.Insert(i, ")");
                                    Parts.Insert(i, Parts[i + 2]);
                                    Parts.Insert(i, ",");
                                    Parts.Insert(i, Parts[i - 1]);
                                    Parts.Insert(i, "(");
                                    Parts.Insert(i, function);

                                    Parts.RemoveAt(i + 6);
                                    Parts.RemoveAt(i + 6);
                                    Parts.RemoveAt(i - 1);
                                }
                                else
                                {
                                    if (Parts[first].ToString().Equals(")") && Parts[second].ToString().Equals("("))
                                    {
                                        int found = 1;
                                        int start = i + 2;

                                        while (found != 0)
                                        {
                                            start++;
                                            if (Parts[start].ToString().Equals("("))
                                                found++;
                                            if (Parts[start].ToString().Equals(")"))
                                                found--;
                                        }

                                        Parts.Insert(start + 1, ")");
                                        Parts[i] = ",";

                                        found = 1;
                                        start = i - 1;

                                        while (found != 0)
                                        {
                                            start--;
                                            if (Parts[start].ToString().Equals(")"))
                                                found++;
                                            if (Parts[start].ToString().Equals("("))
                                                found--;
                                        }

                                        Parts.Insert(start - 1, "(");
                                        Parts.Insert(start - 1, function);
                                    }
                                }
                            }
                        }
                    }
                    catch
                    {
                        OutFile.WriteLine("ERROR: INCORRECT INPUT STRING"); //ERROR: INCORRECT INPUT STRING
                        Form1.Step("ERROR: INCORRECT INPUT STRING");
                        return Tokenize(Base_String);
                    }
                }
            }
            #endregion
            #region SHORTCUT REMOVER + and -
            for (int i = 0; i < Parts.Count; i++)
            { //SHORTCUT REMOVER
                string function;
                if (Parts[i].ToString().Equals("+") || Parts[i].ToString().Equals("-"))
                {
                    //PrintArrayList(Parts);

                    if (Parts[i].ToString().Equals("+"))
                        function = "ADD";
                    else
                        function = "SUB";

                    try
                    {
                        int first = i - 1, second = i + 2;
                        if ((i + 2) >= Parts.Count)
                            second--;
                        if (Parts[first].ToString().Equals(")") && !Parts[second].ToString().Equals("("))
                        {
                            int found = 1;
                            int start = i - 1;

                            while (found != 0)
                            {
                                start--;
                                if (Parts[start].ToString().Equals(")"))
                                    found++;
                                if (Parts[start].ToString().Equals("("))
                                    found--;
                            }

                            Parts.Insert(i, ")");
                            Parts.Insert(i, Parts[i + 2]);
                            Parts.Insert(i, ",");
                            Parts.InsertRange(i, Parts.GetRange(start - 1, i - start + 1));
                            Parts.Insert(i, "(");
                            Parts.Insert(i, function);

                            Parts.RemoveAt(i + (i - start + 1) + 5);
                            Parts.RemoveAt(i + (i - start + 1) + 5);
                            Parts.RemoveRange(start - 1, i - start + 1);
                        }
                        else
                        {
                            if (!Parts[first].ToString().Equals(")") && Parts[second].ToString().Equals("("))
                            {
                                int found = 1;
                                int start = i + 2;

                                while (found != 0)
                                {
                                    start++;
                                    if (Parts[start].ToString().Equals("("))
                                        found++;
                                    if (Parts[start].ToString().Equals(")"))
                                        found--;
                                }

                                Parts.Insert(start + i, ")");
                                Parts.Insert(i + 1, ",");
                                Parts.Insert(i + 1, Parts[i - 1]);
                                Parts.Insert(i + 1, "(");
                                Parts.Insert(i + 1, function);

                                Parts.RemoveAt(i - 1);
                                Parts.RemoveAt(i - 1);
                            }
                            else
                            {
                                if (!Parts[first].ToString().Equals(")") && !Parts[second].ToString().Equals("("))
                                {
                                    Parts.Insert(i, ")");
                                    Parts.Insert(i, Parts[i + 2]);
                                    Parts.Insert(i, ",");
                                    Parts.Insert(i, Parts[i - 1]);
                                    Parts.Insert(i, "(");
                                    Parts.Insert(i, function);

                                    Parts.RemoveAt(i + 6);
                                    Parts.RemoveAt(i + 6);
                                    Parts.RemoveAt(i - 1);
                                }
                                else
                                {
                                    if (Parts[first].ToString().Equals(")") && Parts[second].ToString().Equals("("))
                                    {
                                        int found = 1;
                                        int start = i + 2;

                                        while (found != 0)
                                        {
                                            start++;
                                            if (Parts[start].ToString().Equals("("))
                                                found++;
                                            if (Parts[start].ToString().Equals(")"))
                                                found--;
                                        }

                                        Parts.Insert(start + 1, ")");
                                        Parts[i] = ",";

                                        found = 1;
                                        start = i - 1;

                                        while (found != 0)
                                        {
                                            start--;
                                            if (Parts[start].ToString().Equals(")"))
                                                found++;
                                            if (Parts[start].ToString().Equals("("))
                                                found--;
                                        }

                                        Parts.Insert(start - 1, "(");
                                        Parts.Insert(start - 1, function);
                                    }
                                }
                            }
                        }
                    }
                    catch
                    {
                        OutFile.WriteLine("ERROR: INCORRECT INPUT STRING"); //ERROR: INCORRECT INPUT STRING
                        Form1.Step("ERROR: INCORRECT INPUT STRING");
                        return Tokenize(Base_String);
                    }
                }
            }
            #endregion
            #region SHORTCUT REMOVER :
            for (int i = 0; i < Parts.Count; i++)
            { //SHORTCUT REMOVER 1
                if (Parts[i].ToString().Contains(":"))
                {
                    //PrintArrayList(Parts);

                    char c = Convert.ToChar(Parts[i].ToString().Substring(0, 1));
                    int t1 = Convert.ToInt32(Parts[i].ToString().Split(':')[0].Substring(1));
                    int t2 = Convert.ToInt32(Parts[i].ToString().Split(':')[1].Substring(1));

                    Parts.RemoveAt(i);
                    for (int j = t2; j >= t1; j--)
                    {
                        Parts.Insert(i, c + j.ToString());
                        if (j != t1)
                            Parts.Insert(i, ",");
                    }
                }
            }
            #endregion
            for (int i = 0; i < Parts.Count; i++)
            { //CELL REFERENCE
                if (Base_Cell.CompareTo(Parts[i].ToString().ToUpper()) == 0)
                {
                    OutFile.WriteLine("ERROR: CIRCULAR REFERENCE");
                    Form1.Step("ERROR: CIRCULAR REFERENCE");
                    //ERROR: CIRCULAR REFERENCE
                    return Parts;
                }
                if (IsCellReference(Parts[i].ToString()))
                {
                    OutFile.WriteLine("Cell Reference");
                    Form1.Step("Cell Reference");
                    //Console.WriteLine("BaseCell= " + Base_Cell);
                    //Console.WriteLine("CellReference= " + Parts[i].ToString());

                    string cell_ref = Parts[i].ToString().ToUpper();

                    Parts.RemoveAt(i);
                    //string temp = "=1+2";//temp will equal the output of the UI's function
                    string temp = Form1.getCellFormula(cell_ref);

                    OutFile.WriteLine(cell_ref + " -> " + temp);
                    Form1.Step(cell_ref + " -> " + temp);

                    if (temp[0] == '=')
                    {
                        //Cell has a formula
                        Parts.InsertRange(i, Reformat(Tokenize(temp)));

                        OutFile.WriteLine("Cell has a formula");
                        Form1.Step("Cell has a formula");
                    }
                    else
                    {
                        try
                        {
                            //Cell has a value
                            Parts.Insert(i, Convert.ToDouble(temp));

                            OutFile.WriteLine("Cell has a number");
                            Form1.Step("Cell has a number");
                        }
                        catch
                        {
                            OutFile.WriteLine("Cell has a string");
                            Form1.Step("Cell has a string");
                            //ERROR: Cell has a string
                            return Parts;
                        }
                    }
                }
            }
            
            return Parts;
        }
Example #30
0
        private ResultSet ListFiles(ManagerEngine man, string cmd, Hashtable input)
        {
            ResultSet rs = new ResultSet(new string[] {"name","path","size","type","created","modified","attribs","custom"});
            Hashtable customInfo;
            ArrayList files = new ArrayList();
            BasicFileFilter filter;
            IFile listDir;
            ManagerConfig config = man.Config;
            bool onlyDirs, onlyFiles, remember, hasParent = false;
            string type, attribs, path, rootPath, configPrefixes, name, tmpPath;
            int pages, pageSize;
            HttpRequest req = HttpContext.Current.Request;
            HttpResponse resp = HttpContext.Current.Response;

            // Handle remember_last_path state
            if (input["remember_last_path"] != null) {
                // URL specified
                if (((string) input["path"]) == "{default}") {
                    if (input["url"] != null && (string) input["url"] != "")
                        input["path"] = man.ConvertURIToPath((string) input["url"]);
                }

                path = (string) input["path"];

                if (input["remember_last_path"] is bool)
                    remember = (bool) input["remember_last_path"];
                else if (((string) input["remember_last_path"]) != "auto")
                    remember = StringUtils.CheckBool((string) input["remember_last_path"]);
                else
                    remember = config.GetBool("general.remember_last_path", false);

                // Get/set cookie
                if (remember) {
                    if (path == "{default}" && req.Cookies["MCManager_" + man.Prefix + "_lastPath"] != null) {
                        tmpPath = req.Cookies["MCManager_" + man.Prefix + "_lastPath"].Value;

                        if (tmpPath != null && man.GetFSFromPath(tmpPath) == "file")
                            input["path"] = tmpPath;
                    } else {
                        HttpCookie cookie = new HttpCookie("MCManager_" + man.Prefix + "_lastPath");

                        cookie.Expires = DateTime.Now.AddDays(30);
                        cookie.Value = path;

                        resp.Cookies.Remove("MCManager_" + man.Prefix + "_lastPath");

                        if (man.GetFSFromPath(path) == "file")
                            resp.Cookies.Add(cookie);
                    }
                }
            }

            path = man.DecryptPath((string) input["path"]);
            rootPath = man.DecryptPath((string) input["root_path"]);
            onlyDirs = input["only_dirs"] != null && (bool) input["only_dirs"];
            onlyFiles = input["only_files"] != null && (bool) input["only_files"];
            configPrefixes = (string) input["config"];

            if (man.GetFSFromPath(path) == "file" && !man.VerifyPath(path))
                path = man.Config.Get("filesystem.path");

            // Move path into rootpath
            if (rootPath != null && !PathUtils.IsChildPath(rootPath, path) && man.GetFSFromPath(path) == "file")
                path = rootPath;

            listDir = man.GetFile(path);

            // Use default path instead
            if (!listDir.Exists) {
                path = config["filesystem.path"];
                listDir = man.GetFile(path);
            }

            rs.Header["path"] = man.EncryptPath(path);
            rs.Header["visual_path"] = man.ToVisualPath(path, rootPath);
            rs.Header["attribs"] = (listDir.CanRead ? "R" : "-") + (listDir.CanWrite ? "W" : "-");

            // List files
            if (listDir.IsDirectory) {
                config = listDir.Config;

                // Return part of the config
                if (configPrefixes != null)
                    rs.Config = man.GetJSConfig(config, configPrefixes);

                // Verify filesystem config
                filter = new BasicFileFilter();
                filter.IncludeDirectoryPattern = config["filesystem.include_directory_pattern"];
                filter.ExcludeDirectoryPattern = config["filesystem.exclude_directory_pattern"];
                filter.IncludeFilePattern = config["filesystem.include_file_pattern"];
                filter.ExcludeFilePattern = config["filesystem.exclude_file_pattern"];
                filter.IncludeExtensions = config["filesystem.extensions"];
                filter.OnlyDirs = onlyDirs;

                // Directory is hidden use parent dir
                if (!filter.Accept(listDir)) {
                    listDir = listDir.ParentFile;

                    rs.Header["path"] = man.EncryptPath(listDir.AbsolutePath);
                    rs.Header["visual_path"] = man.ToVisualPath(listDir.AbsolutePath, rootPath);
                }

                if (input["filter"] != null)
                    filter.IncludeWildcardPattern = (string) input["filter"];

                if (input["only_files"] != null)
                    filter.OnlyFiles = onlyFiles;
                else if (!onlyDirs)
                    filter.OnlyFiles = !config.GetBool("filesystem.list_directories", false);

                // Add parent
                if (path != rootPath && input["only_files"] == null && (input["only_dirs"] != null || man.Config.GetBool("filesystem.list_directories", true))) {
                    if (man.VerifyPath(listDir.Parent)) {
                        hasParent = true;
                        rs.Add("..", man.EncryptPath(listDir.Parent), -1, "parent", "", "", "", new NameValueCollection());
                    }
                }

                // Setup input filter
                BasicFileFilter inputFilter = new BasicFileFilter();

                if (input["include_directory_pattern"] != null)
                    filter.IncludeDirectoryPattern = (string) input["include_directory_pattern"];

                if (input["exclude_directory_pattern"] != null)
                    filter.ExcludeDirectoryPattern = (string) input["exclude_directory_pattern"];

                if (input["include_file_pattern"] != null)
                    filter.IncludeFilePattern = (string) input["include_file_pattern"];

                if (input["exclude_file_pattern"] != null)
                    filter.ExcludeFilePattern = (string) input["exclude_file_pattern"];

                if (input["extensions"] != null)
                    filter.IncludeExtensions = (string) input["extensions"];

                // Combine the filters
                CombinedFileFilter combinedFilter = new CombinedFileFilter();

                combinedFilter.AddFilter(inputFilter);
                combinedFilter.AddFilter(filter);

                files.AddRange(listDir.ListFilesFiltered(combinedFilter));

                if (input["page_size"] != null) {
                    if (hasParent)
                        pageSize = Convert.ToInt32(input["page_size"]) - 1;
                    else
                        pageSize = Convert.ToInt32(input["page_size"]);

                    pages = (int) Math.Ceiling(files.Count / (double) pageSize);

                    // Setup response
                    rs.Header["pages"] = (pages > 1 ? pages : 1);
                    rs.Header["count"] = files.Count;

                    // Remove non visible files
                    int start = Convert.ToInt32(input["page"]) * pageSize;
                    int len = pageSize;
                    len = start + len > files.Count ? len - ((start + len) - files.Count) : len;
                    files = files.GetRange(start, len);
                }

                // Sort Files
                files.Sort(new FileComparer());

                // Output folders
                foreach (IFile file in files) {
                    if (file.IsDirectory) {
                        // Setup attribs
                        attribs = "RW";

                        type = "folder";

                        // Fill custom info
                        customInfo = new Hashtable();
                        man.DispatchEvent(EventType.CustomInfo, file, "list", customInfo);

                        // Special treatment of roots
                        name = file.Name;
                        if (path == "root:///") {
                            if (man.RootNames[file.AbsolutePath] != null)
                                name = man.RootNames[file.AbsolutePath];
                        }

                        // Add to resultset
                        rs.Add(
                            name,
                            man.EncryptPath(file.AbsolutePath),
                            file.IsDirectory ? -1 : file.Length,
                            type,
                            StringUtils.GetDate(file.CreationDate, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
                            StringUtils.GetDate(file.LastModified, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
                            attribs,
                            customInfo
                        );
                    }
                }

                // Output files
                foreach (IFile file in files) {
                    if (file.IsFile) {
                        // Setup attribs
                        attribs = "RW";

                        type = PathUtils.GetExtension(file.AbsolutePath).ToLower();

                        // Fill custom info
                        customInfo = new Hashtable();
                        man.DispatchEvent(EventType.CustomInfo, file, "list", customInfo);

                        // Add to resultset
                        rs.Add(
                            file.Name,
                            man.EncryptPath(file.AbsolutePath),
                            file.Length,
                            type,
                            StringUtils.GetDate(file.CreationDate, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
                            StringUtils.GetDate(file.LastModified, listDir.Config.Get("filesystem.datefmt", "yyyy-MM-dd HH:mm")),
                            attribs,
                            customInfo
                        );
                    }
                }
            } else
                throw new ManagerException("{#error.file_not_exists}");

            return rs;
        }