text:
using Alphaleonis.Win32;
using Alphaleonis.Win32.Filesystem;
using Alphaleonis.Win32.Network;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using Directory = Alphaleonis.Win32.Filesystem.Directory;
using DirectoryInfo = Alphaleonis.Win32.Filesystem.DirectoryInfo;
using DriveInfo = Alphaleonis.Win32.Filesystem.DriveInfo;
using File = Alphaleonis.Win32.Filesystem.File;
using FileInfo = Alphaleonis.Win32.Filesystem.FileInfo;
using OperatingSystem = Alphaleonis.Win32.OperatingSystem;
using Path = Alphaleonis.Win32.Filesystem.Path;

namespace AlphaFS.UnitTest
{
   /// <summary>This is a test class for several AlphaFS instance classes.</summary>
   [TestClass]
   public partial class AlphaFS_ClassesTest
   {
      #region Unit Tests

      #region DumpClassByHandleFileInfo

      private void DumpClassByHandleFileInfo(bool isLocal)
      {
         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         string tempPath = Path.GetTempPath("File.GetFileInfoByHandle()-" + Path.GetRandomFileName());
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         Console.WriteLine("\nInput File Path: [{0}]", tempPath);

         FileStream stream = File.Create(tempPath);
         stream.WriteByte(1);

         UnitTestConstants.StopWatcher(true);
         ByHandleFileInfo bhfi = File.GetFileInfoByHandle(stream.SafeFileHandle);
         Console.WriteLine(UnitTestConstants.Reporter());

         Assert.IsTrue(UnitTestConstants.Dump(bhfi, -18));

         Assert.AreEqual(System.IO.File.GetCreationTimeUtc(tempPath), bhfi.CreationTimeUtc);
         Assert.AreEqual(System.IO.File.GetLastAccessTimeUtc(tempPath), bhfi.LastAccessTimeUtc);
         Assert.AreEqual(System.IO.File.GetLastWriteTimeUtc(tempPath), bhfi.LastWriteTimeUtc);

         stream.Close();

         File.Delete(tempPath, true);
         Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
         Console.WriteLine();
      }

      #endregion // DumpClassByHandleFileInfo

      #region DumpClassDeviceInfo

      private void DumpClassDeviceInfo(string host)
      {
         Console.WriteLine("\n=== TEST ===");

         bool allOk = false;
         try
         {
            #region DeviceGuid.Volume

            Console.Write("\nEnumerating volumes from host: [{0}]\n", host);
            int cnt = 0;
            UnitTestConstants.StopWatcher(true);
            foreach (DeviceInfo device in Device.EnumerateDevices(host, DeviceGuid.Volume))
            {
               Console.WriteLine("\n#{0:000}\tClass: [{1}]", ++cnt, device.Class);

               UnitTestConstants.Dump(device, -24);

               try
               {
                  string getDriveLetter = Volume.GetDriveNameForNtDeviceName(device.PhysicalDeviceObjectName);
                  string dosdeviceGuid = Volume.GetVolumeGuidForNtDeviceName(device.PhysicalDeviceObjectName);

                  Console.WriteLine("\n\tVolume.GetDriveNameForNtDeviceName() : [{0}]", getDriveLetter ?? "null");
                  Console.WriteLine("\tVolume.GetVolumeGuidForNtDeviceName(): [{0}]", dosdeviceGuid ?? "null");
               }
               catch (Exception ex)
               {
                  Console.WriteLine("\nCaught (unexpected) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
               }
            }
            Console.WriteLine(UnitTestConstants.Reporter());
            Console.WriteLine();

            #endregion // DeviceGuid.Volume

            #region DeviceGuid.Disk

            Console.Write("\nEnumerating disks from host: [{0}]\n", host);
            cnt = 0;
            UnitTestConstants.StopWatcher(true);
            foreach (DeviceInfo device in Device.EnumerateDevices(host, DeviceGuid.Disk))
            {
               Console.WriteLine("\n#{0:000}\tClass: [{1}]", ++cnt, device.Class);

               UnitTestConstants.Dump(device, -24);

               try
               {
                  string getDriveLetter = Volume.GetDriveNameForNtDeviceName(device.PhysicalDeviceObjectName);
                  string dosdeviceGuid = Volume.GetVolumeGuidForNtDeviceName(device.PhysicalDeviceObjectName);

                  Console.WriteLine("\n\tVolume.GetDriveNameForNtDeviceName() : [{0}]", getDriveLetter ?? "null");
                  Console.WriteLine("\tVolume.GetVolumeGuidForNtDeviceName(): [{0}]", dosdeviceGuid ?? "null");
               }
               catch (Exception ex)
               {
                  Console.WriteLine("\nCaught (unexpected) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
               }
            }
            Console.WriteLine(UnitTestConstants.Reporter());

            #endregion // DeviceGuid.Disk

            allOk = true;
         }
         catch (Exception ex)
         {
            Console.WriteLine("\tCaught (unexpected) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
         }

         Assert.IsTrue(allOk, "Could (probably) not connect to host: [{0}]", host);
         Console.WriteLine();
      }

      #endregion // DumpClassDeviceInfo

      #region DumpClassDirectoryInfo

      private void DumpClassDirectoryInfo(bool isLocal)
      {
         #region Setup

         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         string tempPath = Path.Combine(Path.GetTempPath(), "DirectoryInfo()-" + Path.GetRandomFileName());
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         int expectedLastError;
         string expectedException;

         string nonExistingDirectory = UnitTestConstants.SysRoot32 + @"\NonExistingDirectory-" + Path.GetRandomFileName();
         if (!isLocal) nonExistingDirectory = Path.LocalToUnc(nonExistingDirectory);

         string sysDrive = UnitTestConstants.SysDrive;
         if (!isLocal) sysDrive = Path.LocalToUnc(sysDrive);

         string sysRoot = UnitTestConstants.SysRoot;
         if (!isLocal) sysRoot = Path.LocalToUnc(sysRoot);

         string letter = DriveInfo.GetFreeDriveLetter() + @":\";
         if (!isLocal) letter = Path.LocalToUnc(letter);

         #endregion // Setup

         #region NotSupportedException

         expectedLastError = (int) (isLocal ? Win32Errors.ERROR_ENVVAR_NOT_FOUND : Win32Errors.NERR_UseNotFound);
         expectedException = "System.NotSupportedException";
         bool exception = false;
         try
         {
            Console.WriteLine("\nCatch: [{0}]: The given path's format is not supported.", expectedException);

            string invalidPath = UnitTestConstants.SysDrive + @"\:a";
            if (!isLocal) invalidPath = Path.LocalToUnc(invalidPath) + @":a";

            DirectoryInfo di = new DirectoryInfo(invalidPath);
         }
         catch (Exception ex)
         {
            // Not reliable.
            //var win32Error = new Win32Exception("", ex);
            //Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
            //Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));

            string exceptionTypeName = ex.GetType().FullName;
            if (exceptionTypeName.Equals(expectedException))
            {
               exception = true;
               Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
            }
            else
               Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
         }
         Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
         Console.WriteLine();

         #endregion // NotSupportedException

         #region Current Directory

         tempPath = Path.CurrentDirectoryPrefix;
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         Console.WriteLine("\nInput Directory Path (Current directory): [{0}]\n", tempPath);

         UnitTestConstants.StopWatcher(true);
         System.IO.DirectoryInfo expected = new System.IO.DirectoryInfo(tempPath);
         Console.WriteLine("\tSystem.IO DirectoryInfo(){0}", UnitTestConstants.Reporter());

         UnitTestConstants.StopWatcher(true);
         DirectoryInfo actual = new DirectoryInfo(tempPath);
         Console.WriteLine("\tAlphaFS DirectoryInfo(){0}", UnitTestConstants.Reporter());

         // Compare values of both instances.
         CompareDirectoryInfos(expected, actual);

         #endregion // Current Directory

         #region Non-Existing Directory

         Console.WriteLine("\nInput Directory Path: [{0}]\n", nonExistingDirectory);

         UnitTestConstants.StopWatcher(true);
         expected = new System.IO.DirectoryInfo(tempPath);
         Console.WriteLine("\tSystem.IO DirectoryInfo(){0}", UnitTestConstants.Reporter());

         UnitTestConstants.StopWatcher(true);
         actual = new DirectoryInfo(tempPath);
         Console.WriteLine("\tAlphaFS DirectoryInfo(){0}", UnitTestConstants.Reporter());

         // Compare values of both instances.
         CompareDirectoryInfos(expected, actual);

         #endregion // Non-Existing Directory

         #region Existing Directory

         tempPath = Path.Combine(Path.GetTempPath(), "DirectoryInfo()-Directory-" + Path.GetRandomFileName());
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         try
         {
            Directory.CreateDirectory(tempPath);

            Console.WriteLine("\n\nInput Directory Path: [{0}]\n", tempPath);

            UnitTestConstants.StopWatcher(true);
            expected = new System.IO.DirectoryInfo(tempPath);
            Console.WriteLine("\tSystem.IO DirectoryInfo(){0}", UnitTestConstants.Reporter());

            UnitTestConstants.StopWatcher(true);
            actual = new DirectoryInfo(tempPath);
            Console.WriteLine("\tAlphaFS DirectoryInfo(){0}", UnitTestConstants.Reporter());

            // Compare values of both instances.
            CompareDirectoryInfos(expected, actual);
         }
         finally
         {
             if (Directory.Exists(tempPath))
                 Directory.Delete(tempPath);

            Assert.IsFalse(Directory.Exists(tempPath), "Cleanup failed: Directory should have been removed.");
         }

         #endregion // Existing Directory

         #region Method .ToString()

         Console.WriteLine("\nMethod .ToString()");
         Console.WriteLine("Both strings should be the same.\n");

         expected = new System.IO.DirectoryInfo("ToString()-TestDirectory");
         actual = new DirectoryInfo("ToString()-TestDirectory");

         string expectedToString = expected.ToString();
         string actualToString = actual.ToString();

         Console.WriteLine("\tSystem.IO: [{0}]", expectedToString);
         Console.WriteLine("\tAlphaFS  : [{0}]", actualToString);

         Assert.AreEqual(expectedToString, actualToString, false);
         Console.WriteLine();

         #endregion Method .ToString()
      }

      private void CompareDirectoryInfos(System.IO.DirectoryInfo expected, DirectoryInfo actual)
      {
         if (expected == null || actual == null)
            Assert.AreEqual(expected, actual, "Mismatch");

         UnitTestConstants.Dump(expected, -17);
         UnitTestConstants.Dump(actual, -17);

         int errorCnt = 0;
         int cnt = -1;
         while (cnt != 13)
         {
            cnt++;

            if (expected == null || actual == null)
               Assert.AreEqual(expected, actual, "One or both of the DirectoryInfo instances is/are null.");

            else
            {
               try
               {
                  // Compare values of both instances.
                  switch (cnt)
                  {
                     case 0: Assert.AreEqual(expected.Attributes, actual.Attributes, "Attributes AlphaFS != System.IO"); break;
                     case 1: Assert.AreEqual(expected.CreationTime, actual.CreationTime, "CreationTime AlphaFS != System.IO"); break;
                     case 2: Assert.AreEqual(expected.CreationTimeUtc, actual.CreationTimeUtc, "CreationTimeUtc AlphaFS != System.IO"); break;
                     case 3: Assert.AreEqual(expected.Exists, actual.Exists, "Exists AlphaFS != System.IO"); break;
                     case 4: Assert.AreEqual(expected.Extension, actual.Extension, "Extension AlphaFS != System.IO"); break;
                     case 5: Assert.AreEqual(expected.FullName, actual.FullName, "FullName AlphaFS != System.IO"); break;
                     case 6: Assert.AreEqual(expected.LastAccessTime, actual.LastAccessTime, "LastAccessTime AlphaFS != System.IO"); break;
                     case 7: Assert.AreEqual(expected.LastAccessTimeUtc, actual.LastAccessTimeUtc, "LastAccessTimeUtc AlphaFS != System.IO"); break;
                     case 8: Assert.AreEqual(expected.LastWriteTime, actual.LastWriteTime, "LastWriteTime AlphaFS != System.IO"); break;
                     case 9: Assert.AreEqual(expected.LastWriteTimeUtc, actual.LastWriteTimeUtc, "LastWriteTimeUtc AlphaFS != System.IO"); break;
                     case 10: Assert.AreEqual(expected.Name, actual.Name, "Name AlphaFS != System.IO"); break;

                     // Need .ToString() here since the object types are obviously not the same.
                     case 11: Assert.AreEqual(expected.Parent.ToString(), actual.Parent.ToString(), "Parent AlphaFS != System.IO"); break;
                     case 12: Assert.AreEqual(expected.Root.ToString(), actual.Root.ToString(), "Root AlphaFS != System.IO"); break;
                  }
               }
               catch (Exception ex)
               {
                  errorCnt++;
                  Console.WriteLine("\n\t\tProperty cnt #{0}\tCaught {1}: [{2}]", (cnt + 1), ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
               }
            }
         }

         //Assert.IsTrue(errorCnt == 0, "\tEncountered: [{0}] DirectoryInfo Properties where AlphaFS != System.IO", errorCnt);
         Console.WriteLine();
      }

      #endregion // DumpClassDirectoryInfo

      #region DumpClassDiskSpaceInfo

      private void DumpClassDiskSpaceInfo(bool isLocal)
      {
         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         string tempPath = UnitTestConstants.SysDrive;
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);
         Console.WriteLine("\nInput Path: [{0}]", tempPath);

         int cnt = 0;
         int errorCount = 0;

          // Get only .IsReady drives.
         foreach (var drv in Directory.EnumerateLogicalDrives(false, true))
         {
            if (drv.DriveType == DriveType.NoRootDirectory)
               continue;

            string drive = isLocal ? drv.Name : Path.LocalToUnc(drv.Name);

            UnitTestConstants.StopWatcher(true);

            try
            {
               // null (default) == All information.
               DiskSpaceInfo dsi = drv.DiskSpaceInfo;
               string report = UnitTestConstants.Reporter(true);

               Console.WriteLine("\n#{0:000}\tInput Path: [{1}]{2}", ++cnt, drive, report);
               Assert.IsTrue(UnitTestConstants.Dump(dsi, -26));

               Assert.AreNotEqual((int) 0, (int) dsi.BytesPerSector);
               Assert.AreNotEqual((int) 0, (int) dsi.SectorsPerCluster);
               Assert.AreNotEqual((int) 0, (int) dsi.TotalNumberOfClusters);
               Assert.AreNotEqual((int) 0, (int) dsi.TotalNumberOfBytes);

               if (drv.DriveType == DriveType.CDRom)
               {
                  Assert.AreEqual((int) 0, (int) dsi.FreeBytesAvailable);
                  Assert.AreEqual((int) 0, (int) dsi.NumberOfFreeClusters);
                  Assert.AreEqual((int) 0, (int) dsi.TotalNumberOfFreeBytes);
               }
               else
               {
                  Assert.AreNotEqual((int) 0, (int) dsi.FreeBytesAvailable);
                  Assert.AreNotEqual((int) 0, (int) dsi.NumberOfFreeClusters);
                  Assert.AreNotEqual((int) 0, (int) dsi.TotalNumberOfFreeBytes);
               }

               // false == Size information only.
               dsi = Volume.GetDiskFreeSpace(drive, false);
               Assert.AreEqual((int)0, (int)dsi.BytesPerSector);
               Assert.AreEqual((int)0, (int)dsi.NumberOfFreeClusters);
               Assert.AreEqual((int)0, (int)dsi.SectorsPerCluster);
               Assert.AreEqual((int)0, (int)dsi.TotalNumberOfClusters);

               // true == Cluster information only.
               dsi = Volume.GetDiskFreeSpace(drive, true);
               Assert.AreEqual((int)0, (int)dsi.FreeBytesAvailable);
               Assert.AreEqual((int)0, (int)dsi.TotalNumberOfBytes);
               Assert.AreEqual((int)0, (int)dsi.TotalNumberOfFreeBytes);
            }
            catch (Exception ex)
            {
               Console.WriteLine("\n\nCaught (unexpected) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
               errorCount++;
            }
         }

         if (cnt == 0)
            Assert.Inconclusive("Nothing was enumerated.");

         Assert.AreEqual(0, errorCount, "No errors were expected.");
         Console.WriteLine();
      }

      #endregion // DumpClassDiskSpaceInfo

      #region DumpClassDriveInfo

      private void DumpClassDriveInfo(bool isLocal, string drive)
      {
         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         string tempPath = drive;
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         UnitTestConstants.StopWatcher(true);
         DriveInfo actual = new DriveInfo(tempPath);
         Console.WriteLine("\nInput Path: [{0}]{1}", tempPath, UnitTestConstants.Reporter());

         #region UnitTestConstants.Local Drive
         if (isLocal)
         {
            // System.IO.DriveInfo() can not handle UNC paths.
            System.IO.DriveInfo expected = new System.IO.DriveInfo(tempPath);
            //Dump(expected, -21);

            // Even 1 byte more or less results in failure, so do these tests asap.
            Assert.AreEqual(expected.AvailableFreeSpace, actual.AvailableFreeSpace, "AvailableFreeSpace AlphaFS != System.IO");
            Assert.AreEqual(expected.TotalFreeSpace, actual.TotalFreeSpace, "TotalFreeSpace AlphaFS != System.IO");
            Assert.AreEqual(expected.TotalSize, actual.TotalSize, "TotalSize AlphaFS != System.IO");

            Assert.AreEqual(expected.DriveFormat, actual.DriveFormat, "DriveFormat AlphaFS != System.IO");
            Assert.AreEqual(expected.DriveType, actual.DriveType, "DriveType AlphaFS != System.IO");
            Assert.AreEqual(expected.IsReady, actual.IsReady, "IsReady AlphaFS != System.IO");
            Assert.AreEqual(expected.Name, actual.Name, "Name AlphaFS != System.IO");
            Assert.AreEqual(expected.RootDirectory.ToString(), actual.RootDirectory.ToString(), "RootDirectory AlphaFS != System.IO");
            Assert.AreEqual(expected.VolumeLabel, actual.VolumeLabel, "VolumeLabel AlphaFS != System.IO");
         }

         #region Class Equality

         ////int getHashCode1 = actual.GetHashCode();

         //DriveInfo driveInfo2 = new DriveInfo(tempPath);
         ////int getHashCode2 = driveInfo2.GetHashCode();

         //DriveInfo clone = actual;
         ////int getHashCode3 = clone.GetHashCode();

         //bool isTrue1 = clone.Equals(actual);
         //bool isTrue2 = clone == actual;
         //bool isTrue3 = !(clone != actual);
         //bool isTrue4 = actual == driveInfo2;
         //bool isTrue5 = !(actual != driveInfo2);

         ////Console.WriteLine("\n\t\t actual.GetHashCode() : [{0}]", getHashCode1);
         ////Console.WriteLine("\t\t     clone.GetHashCode() : [{0}]", getHashCode3);
         ////Console.WriteLine("\t\tdriveInfo2.GetHashCode() : [{0}]\n", getHashCode2);

         ////Console.WriteLine("\t\t obj clone.ToString() == [{0}]", clone.ToString());
         ////Console.WriteLine("\t\t obj clone.Equals()   == [{0}] : {1}", TextTrue, isTrue1);
         ////Console.WriteLine("\t\t obj clone ==         == [{0}] : {1}", TextTrue, isTrue2);
         ////Console.WriteLine("\t\t obj clone !=         == [{0}]: {1}\n", TextFalse, isTrue3);

         ////Console.WriteLine("\t\tdriveInfo == driveInfo2 == [{0}] : {1}", TextTrue, isTrue4);
         ////Console.WriteLine("\t\tdriveInfo != driveInfo2 == [{0}] : {1}", TextFalse, isTrue5);

         //Assert.IsTrue(isTrue1, "clone.Equals(actual)");
         //Assert.IsTrue(isTrue2, "clone == actual");
         //Assert.IsTrue(isTrue3, "!(clone != actual)");
         //Assert.IsTrue(isTrue4, "actual == driveInfo2");
         //Assert.IsTrue(isTrue5, "!(actual != driveInfo2)");

         #endregion // Class Equality

         #endregion // UnitTestConstants.Local Drive

         UnitTestConstants.StopWatcher(true);
         UnitTestConstants.Dump(actual, -21);

         UnitTestConstants.Dump(actual.DiskSpaceInfo, -26);

         //if (expected != null) Dump(expected.RootDirectory, -17);
         //Dump(actual.RootDirectory, -17);

         UnitTestConstants.Dump(actual.VolumeInfo, -26);

         Console.WriteLine(UnitTestConstants.Reporter());
         Console.WriteLine();
      }

      #endregion // DumpClassDriveInfo

      #region DumpClassFileInfo

      private void DumpClassFileInfo(bool isLocal)
      {
         #region Setup

         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         string tempPath = Path.Combine(Path.GetTempPath(), "FileInfo()-" + Path.GetRandomFileName());
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         int expectedLastError;
         string expectedException;

         string nonExistingFile = UnitTestConstants.SysRoot32 + @"\NonExistingFile-" + Path.GetRandomFileName();
         if (!isLocal) nonExistingFile = Path.LocalToUnc(nonExistingFile);

         string sysDrive = UnitTestConstants.SysDrive;
         if (!isLocal) sysDrive = Path.LocalToUnc(sysDrive);

         string sysRoot = UnitTestConstants.SysRoot;
         if (!isLocal) sysRoot = Path.LocalToUnc(sysRoot);

         string letter = DriveInfo.GetFreeDriveLetter() + @":\";
         if (!isLocal) letter = Path.LocalToUnc(letter);

         #endregion // Setup

         #region NotSupportedException

         expectedLastError = (int) (isLocal ? Win32Errors.ERROR_ENVVAR_NOT_FOUND : Win32Errors.NERR_UseNotFound);
         expectedException = "System.NotSupportedException";
         bool exception = false;
         try
         {
            Console.WriteLine("\nCatch: [{0}]: The given path's format is not supported.", expectedException);

            string invalidPath = UnitTestConstants.SysDrive + @"\:a";
            if (!isLocal) invalidPath = Path.LocalToUnc(invalidPath) + @":a";

            FileInfo fi = new FileInfo(invalidPath);
         }
         catch (Exception ex)
         {
            // Not reliable.
            //var win32Error = new Win32Exception("", ex);
            //Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
            //Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));

            string exceptionTypeName = ex.GetType().FullName;
            if (exceptionTypeName.Equals(expectedException))
            {
               exception = true;
               Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
            }
            else
               Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
         }
         Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
         Console.WriteLine();

         #endregion // NotSupportedException

         #region Length Property

         #region FileNotFoundException #1

         expectedLastError = (int) Win32Errors.ERROR_FILE_NOT_FOUND;
         expectedException = "System.IO.FileNotFoundException";
         exception = false;
         try
         {
            Console.WriteLine("\nCatch: [{0}]: Length property is called, the file does not exist.", expectedException);
            Console.WriteLine(new FileInfo(nonExistingFile).Length);
         }
         catch (Exception ex)
         {
            var win32Error = new Win32Exception("", ex);
            Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
            Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));

            string exceptionTypeName = ex.GetType().FullName;
            if (exceptionTypeName.Equals(expectedException))
            {
               exception = true;
               Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
            }
            else
               Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
         }
         Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
         Console.WriteLine();

         #endregion // FileNotFoundException #1

         #region FileNotFoundException #2

         expectedLastError = (int) (isLocal ? Win32Errors.ERROR_PATH_NOT_FOUND : Win32Errors.ERROR_BAD_NET_NAME);
         expectedException = isLocal ? "System.IO.FileNotFoundException" : "System.IO.IOException";
         exception = false;
         try
         {
            Console.WriteLine("\nCatch: [{0}]: Length property is called, the file does not exist (Unmapped drive).", expectedException);

            Console.WriteLine(new FileInfo(nonExistingFile.Replace(sysDrive + @"\", letter)).Length);
         }
         catch (Exception ex)
         {
            var win32Error = new Win32Exception("", ex);
            Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
            //Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));

            string exceptionTypeName = ex.GetType().FullName;
            if (exceptionTypeName.Equals(expectedException))
            {
               exception = true;
               Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
            }
            else
               Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
         }
         Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
         Console.WriteLine();

         #endregion // FileNotFoundException #1

         #region FileNotFoundException #3

         expectedLastError = (int) Win32Errors.ERROR_FILE_NOT_FOUND;
         expectedException = "System.IO.FileNotFoundException";
         exception = false;
         try
         {
            Console.WriteLine("\nCatch: [{0}]: Length property is called, the file is a directory.", expectedException);
            Console.WriteLine(new FileInfo(sysRoot).Length);
         }
         catch (Exception ex)
         {
            // win32Error is always 0
            //var win32Error = new Win32Exception("", ex);
            //Assert.IsTrue(win32Error.NativeErrorCode == expectedLastError, string.Format("Expected Win32Exception error should be: [{0}], got: [{1}]", expectedLastError, win32Error.NativeErrorCode));
            Assert.IsTrue(ex.Message.StartsWith("(" + expectedLastError + ")"), string.Format("Expected Win32Exception error is: [{0}]", expectedLastError));

            string exceptionTypeName = ex.GetType().FullName;
            if (exceptionTypeName.Equals(expectedException))
            {
               exception = true;
               Console.WriteLine("\n\t[{0}]: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
            }
            else
               Console.WriteLine("\n\tCaught (unexpected) {0}: [{1}]", exceptionTypeName, ex.Message.Replace(Environment.NewLine, "  "));
         }
         Assert.IsTrue(exception, "[{0}] should have been caught.", expectedException);
         Console.WriteLine();

         #endregion // FileNotFoundException #3

         #endregion // Length Property

         #region Current Directory

         tempPath = Path.CurrentDirectoryPrefix;
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         Console.WriteLine("\nInput File Path (Current directory): [{0}]\n", tempPath);

         UnitTestConstants.StopWatcher(true);
         System.IO.FileInfo expected = new System.IO.FileInfo(tempPath);
         Console.WriteLine("\tSystem.IO FileInfo(){0}", UnitTestConstants.Reporter());

         UnitTestConstants.StopWatcher(true);
         FileInfo actual = new FileInfo(tempPath);
         Console.WriteLine("\tAlphaFS FileInfo(){0}", UnitTestConstants.Reporter());

         // Compare values of both instances.
         CompareFileInfos(expected, actual);

         #endregion // Current Directory

         #region Non-Existing File

         Console.WriteLine("\nInput File Path: [{0}]\n", nonExistingFile);

         UnitTestConstants.StopWatcher(true);
         expected = new System.IO.FileInfo(nonExistingFile);
         Console.WriteLine("\tSystem.IO FileInfo(){0}", UnitTestConstants.Reporter());

         UnitTestConstants.StopWatcher(true);
         actual = new FileInfo(nonExistingFile);
         Console.WriteLine("\tAlphaFS FileInfo(){0}", UnitTestConstants.Reporter());

         // Compare values of both instances.
         CompareFileInfos(expected, actual);

         #endregion // Non-Existing File

         #region Existing File

         tempPath = Path.Combine(Path.GetTempPath(), "FileInfo()-File-" + Path.GetRandomFileName());
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         try
         {
            using (File.Create(tempPath)) {}

            Console.WriteLine("\nInput File Path: [{0}]\n", tempPath);

            UnitTestConstants.StopWatcher(true);
            expected = new System.IO.FileInfo(tempPath);
            Console.WriteLine("\tSystem.IO FileInfo(){0}", UnitTestConstants.Reporter());

            UnitTestConstants.StopWatcher(true);
            actual = new FileInfo(tempPath);
            Console.WriteLine("\tAlphaFS FileInfo(){0}", UnitTestConstants.Reporter());

            // Compare values of both instances.
            CompareFileInfos(expected, actual);
         }
         finally
         {
            File.Delete(tempPath);
            Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");
         }

         #endregion // Existing File

         #region Method .ToString()

         Console.WriteLine("\nMethod .ToString()");
         Console.WriteLine("Both strings should be the same.\n");

         expected = new System.IO.FileInfo("ToString()-TestFile");
         actual = new FileInfo("ToString()-TestFile");

         string expectedToString = expected.ToString();
         string actualToString = actual.ToString();

         Console.WriteLine("\tSystem.IO: [{0}]", expectedToString);
         Console.WriteLine("\tAlphaFS  : [{0}]", actualToString);

         Assert.AreEqual(expectedToString, actualToString, false);
         Console.WriteLine();

         #endregion Method .ToString()
      }

      private void CompareFileInfos(System.IO.FileInfo expected, FileInfo actual)
      {
         if (expected == null || actual == null)
            Assert.AreEqual(expected, actual, "Mismatch");

         UnitTestConstants.Dump(expected, -17);
         UnitTestConstants.Dump(actual, -17);

         int errorCnt = 0;
         int cnt = -1;
         while (cnt != 15)
         {
            cnt++;
            try
            {
               // Compare values of both instances.
               switch (cnt)
               {
                  case 0:
                     Assert.AreEqual(expected.Attributes, actual.Attributes, "Attributes AlphaFS != System.IO");
                     break;
                  case 1:
                     Assert.AreEqual(expected.CreationTime, actual.CreationTime, "CreationTime AlphaFS != System.IO");
                     break;
                  case 2:
                     Assert.AreEqual(expected.CreationTimeUtc, actual.CreationTimeUtc, "CreationTimeUtc AlphaFS != System.IO");
                     break;

                  // Need .ToString() here since the object types are obviously not the same.
                  case 3:
                     Assert.AreEqual(expected.Directory.ToString(), actual.Directory.ToString(), "Directory AlphaFS != System.IO");
                     break;

                  case 4:
                     Assert.AreEqual(expected.DirectoryName, actual.DirectoryName, "DirectoryName AlphaFS != System.IO");
                     break;
                  case 5:
                     Assert.AreEqual(expected.Exists, actual.Exists, "Exists AlphaFS != System.IO");
                     break;
                  case 6:
                     Assert.AreEqual(expected.Extension, actual.Extension, "Extension AlphaFS != System.IO");
                     break;
                  case 7:
                     Assert.AreEqual(expected.FullName, actual.FullName, "FullName AlphaFS != System.IO");
                     break;
                  case 8:
                     Assert.AreEqual(expected.IsReadOnly, actual.IsReadOnly, "IsReadOnly AlphaFS != System.IO");
                     break;
                  case 9:
                     Assert.AreEqual(expected.LastAccessTime, actual.LastAccessTime, "LastAccessTime AlphaFS != System.IO");
                     break;
                  case 10:
                     Assert.AreEqual(expected.LastAccessTimeUtc, actual.LastAccessTimeUtc, "LastAccessTimeUtc AlphaFS != System.IO");
                     break;
                  case 11:
                     Assert.AreEqual(expected.LastWriteTime, actual.LastWriteTime, "LastWriteTime AlphaFS != System.IO");
                     break;
                  case 12:
                     Assert.AreEqual(expected.LastWriteTimeUtc, actual.LastWriteTimeUtc, "LastWriteTimeUtc AlphaFS != System.IO");
                     break;
                  case 13:
                     Assert.AreEqual(expected.Length, actual.Length, "Length AlphaFS != System.IO");
                     break;
                  case 14:
                     Assert.AreEqual(expected.Name, actual.Name, "Name AlphaFS != System.IO");
                     break;
               }
            }
            catch (Exception ex)
            {
               errorCnt++;
               Console.WriteLine("\n\t\t\tProperty cnt #{0}\tCaught {1}: [{2}]", (cnt + 1), ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
            }
         }

         //Assert.IsTrue(errorCnt == 0, "\tEncountered: [{0}] FileInfo Properties where AlphaFS != System.IO", errorCnt);
         Console.WriteLine();
      }

      #endregion // DumpClassFileInfo

      #region DumpClassFileSystemEntryInfo

      private void DumpClassFileSystemEntryInfo(bool isLocal)
      {
         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);

         Console.WriteLine("\nThe return type is based on C# inference. Possible return types are:");
         Console.WriteLine("string (full path), FileSystemInfo (DiskInfo / FileInfo) or FileSystemEntryInfo instance.\n");

         #region Directory

         string path = UnitTestConstants.SysRoot;
         if (!isLocal) path = Path.LocalToUnc(path);

         Console.WriteLine("\nInput Directory Path: [{0}]", path);

         Console.WriteLine("\n\nvar fsei = Directory.GetFileSystemEntry(path);");
         var asFileSystemEntryInfo = File.GetFileSystemEntryInfo(path);
         Assert.IsTrue((asFileSystemEntryInfo.GetType().IsEquivalentTo(typeof(FileSystemEntryInfo))));
         Assert.IsTrue(UnitTestConstants.Dump(asFileSystemEntryInfo, -17));

         Console.WriteLine();

         #endregion // Directory

         #region File

         path = UnitTestConstants.NotepadExe;
         if (!isLocal) path = Path.LocalToUnc(path);

         Console.WriteLine("\nInput File Path: [{0}]", path);

         Console.WriteLine("\n\nvar fsei = File.GetFileSystemEntry(path);");
         asFileSystemEntryInfo = File.GetFileSystemEntryInfo(path);
         Assert.IsTrue((asFileSystemEntryInfo.GetType().IsEquivalentTo(typeof(FileSystemEntryInfo))));
         Assert.IsTrue(UnitTestConstants.Dump(asFileSystemEntryInfo, -17));

         Console.WriteLine();

         #endregion // File
      }

      #endregion // DumpClassFileSystemEntryInfo

      #region DumpClassShell32Info

      private void DumpClassShell32Info(bool isLocal)
      {
         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         string tempPath = Path.GetTempPath("Class.Shell32Info()-" + Path.GetRandomFileName());
         if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

         Console.WriteLine("\nInput File Path: [{0}]\n", tempPath);

         using (File.Create(tempPath))
         {}

         UnitTestConstants.StopWatcher(true);
         Shell32Info shell32Info = Shell32.GetShell32Info(tempPath);
         string report = UnitTestConstants.Reporter();

         Console.WriteLine("\tMethod: Shell32Info.Refresh()");
         Console.WriteLine("\tMethod: Shell32Info.GetIcon()");

         string cmd = "print";
         Console.WriteLine("\tMethod: Shell32Info.GetVerbCommand(\"{0}\") == [{1}]", cmd, shell32Info.GetVerbCommand(cmd));

         Assert.IsTrue(UnitTestConstants.Dump(shell32Info, -15));

         File.Delete(tempPath, true);
         Assert.IsFalse(File.Exists(tempPath), "Cleanup failed: File should have been removed.");

         Console.WriteLine("\n{0}", report);
         Console.WriteLine();
      }

      #endregion // DumpClassShell32Info

      #region DumpClassVolumeInfo

      private void DumpClassVolumeInfo(bool isLocal)
      {
         Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network);
         Console.WriteLine("\nEnumerating logical drives.");

         int cnt = 0;
         foreach (string drive in Directory.GetLogicalDrives())
         {
            string tempPath = drive;
            if (!isLocal) tempPath = Path.LocalToUnc(tempPath);

            UnitTestConstants.StopWatcher(true);
            try
            {
               VolumeInfo volInfo = Volume.GetVolumeInfo(tempPath);
               Console.WriteLine("\n#{0:000}\tLogical Drive: [{1}]", ++cnt, tempPath);
               UnitTestConstants.Dump(volInfo, -26);
            }
            catch (Exception ex)
            {
               Console.WriteLine("#{0:000}\tLogical Drive: [{1}]\n\tCaught: {2}: {3}", ++cnt, tempPath, ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
            }
            Console.WriteLine();
         }

         if (cnt == 0)
            Assert.Inconclusive("Nothing was enumerated.");

         Console.WriteLine();
      }

      #endregion // DumpClassVolumeInfo

      #region DumpClassDfsInfo

      private void DumpClassDfsInfo()
      {
         int cnt = 0;
         bool noDomainConnection = true;

         UnitTestConstants.StopWatcher(true);
         try
         {
            foreach (string dfsNamespace in Host.EnumerateDomainDfsRoot())
            {
               noDomainConnection = false;

               try
               {
                  Console.Write("\n#{0:000}\tDFS Root: [{1}]\n", ++cnt, dfsNamespace);

                  DfsInfo dfsInfo = Host.GetDfsInfo(dfsNamespace);

                  UnitTestConstants.Dump(dfsInfo, -21);

                  Console.Write("\n\tNumber of Storages: [{0}]\n", dfsInfo.StorageInfoCollection.Count());

                  foreach (DfsStorageInfo store in dfsInfo.StorageInfoCollection)
                     UnitTestConstants.Dump(store, -19);

                  Console.WriteLine();
               }
               catch (NetworkInformationException ex)
               {
                  Console.WriteLine("\n\tNetworkInformationException #1: [{0}]", ex.Message.Replace(Environment.NewLine, "  "));
               }
               catch (Exception ex)
               {
                  Console.WriteLine("\n\t(1) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
               }
            }
            Console.Write("\n{0}", UnitTestConstants.Reporter());

            if (cnt == 0)
               Assert.Inconclusive("Nothing was enumerated.");
         }
         catch (NetworkInformationException ex)
         {
            Console.WriteLine("\n\tNetworkInformationException #2: [{0}]", ex.Message.Replace(Environment.NewLine, "  "));
         }
         catch (Exception ex)
         {
            Console.WriteLine("\n\t(2) {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, "  "));
         }

         Console.WriteLine("\n\n\t{0}", UnitTestConstants.Reporter(true));

         if (noDomainConnection)
            Assert.Inconclusive("Test ignored because the computer is probably not connected to a domain.");

         if (cnt == 0)
            Assert.Inconclusive("Nothing was enumerated.");

         Console.WriteLine();
      }

      #endregion // DumpClassDfsInfo

      #region DumpOpenConnectionInfo

      private void DumpOpenConnectionInfo(string host)
      {
         Console.WriteLine("\n=== TEST ===");
         Console.WriteLine("\nNetwork.Host.EnumerateOpenResources() from host: [{0}]", host);

         UnitTestConstants.StopWatcher(true);
         foreach (OpenConnectionInfo connectionInfo in Host.EnumerateOpenConnections(host, "IPC$", false))
            UnitTestConstants.Dump(connectionInfo, -16);

         Console.WriteLine(UnitTestConstants.Reporter(true));
         Console.WriteLine();
      }

      #endregion // DumpClassOpenResourceInfo

      #region DumpClassOpenResourceInfo

      private void DumpClassOpenResourceInfo(string host, string share)
      {
         Console.WriteLine("\n=== TEST ===");
         string tempPath = Path.LocalToUnc(share);
         Console.WriteLine("\nNetwork.Host.EnumerateOpenResources() from host: [{0}]", tempPath);

         Directory.SetCurrentDirectory(tempPath);

         UnitTestConstants.StopWatcher(true);
         int cnt = 0;
         foreach (OpenResourceInfo openResource in Host.EnumerateOpenResources(host, null, null, false))
         {
            if (UnitTestConstants.Dump(openResource, -11))
            {
               Console.Write("\n");
               cnt++;
            }
         }

         Console.WriteLine(UnitTestConstants.Reporter());

         if (cnt == 0)
            Assert.Inconclusive("Nothing was enumerated.");

         Console.WriteLine();
      }

      #endregion // DumpClassOpenResourceInfo

      #region DumpClassShareInfo

      #endregion // DumpClassShareInfo

      #endregion // Unit Tests

      #region Unit Test Callers

      #region Filesystem

      #region Filesystem_Class_ByHandleFileInfo

      [TestMethod]
      public void Filesystem_Class_ByHandleFileInfo()
      {
         Console.WriteLine("Class Filesystem.ByHandleFileInfo()");

         DumpClassByHandleFileInfo(true);
         DumpClassByHandleFileInfo(false);
      }

      #endregion // Filesystem_Class_ByHandleFileInfo

      #region Filesystem_Class_DeviceInfo

      [TestMethod]
      public void Filesystem_Class_DeviceInfo()
      {
         Console.WriteLine("Class Filesystem.DeviceInfo()");
         Console.WriteLine("\nMSDN Note: Beginning in Windows 8 and Windows Server 2012 functionality to access remote machines has been removed.");
         Console.WriteLine("You cannot access remote machines when running on these versions of Windows.\n");

         DumpClassDeviceInfo(UnitTestConstants.LocalHost);
      }

      #endregion // Filesystem_Class_Shell32Info

      #region Filesystem_Class_DirectoryInfo

      [TestMethod]
      public void Filesystem_Class_DirectoryInfo()
      {
         Console.WriteLine("Class Filesystem.DirectoryInfo()");

         DumpClassDirectoryInfo(true);
         DumpClassDirectoryInfo(false);
      }

      #endregion // Filesystem_Class_DirectoryInfo

      #region Filesystem_Class_DiskSpaceInfo

      [TestMethod]
      public void Filesystem_Class_DiskSpaceInfo()
      {
         Console.WriteLine("Class Filesystem.DiskSpaceInfo()");

         DumpClassDiskSpaceInfo(true);
         DumpClassDiskSpaceInfo(false);
      }

      #endregion // Filesystem_Class_DiskSpaceInfo

      #region Filesystem_Class_DriveInfo

      [TestMethod]
      public void Filesystem_Class_DriveInfo()
      {
         Console.WriteLine("Class Filesystem.DriveInfo()");

         DumpClassDriveInfo(true, UnitTestConstants.SysDrive);
         DumpClassDriveInfo(false, UnitTestConstants.SysDrive);
      }

      #endregion // Filesystem_Class_DriveInfo

      #region Filesystem_Class_FileInfo

      [TestMethod]
      public void Filesystem_Class_FileInfo()
      {
         Console.WriteLine("Class Filesystem.FileInfo()");

         DumpClassFileInfo(true);
         DumpClassFileInfo(false);
      }

      #endregion // Filesystem_Class_FileInfo

      #region Filesystem_Class_FileSystemEntryInfo

      [TestMethod]
      public void Filesystem_Class_FileSystemEntryInfo()
      {
         Console.WriteLine("Class Filesystem.FileSystemEntryInfo()");

         DumpClassFileSystemEntryInfo(true);
         DumpClassFileSystemEntryInfo(false);
      }

      #endregion // Filesystem_Class_FileSystemEntryInfo

      #region Filesystem_Class_Shell32Info

      [TestMethod]
      public void Filesystem_Class_Shell32Info()
      {
         Console.WriteLine("Class Filesystem.Shell32Info()");

         DumpClassShell32Info(true);
         DumpClassShell32Info(false);
      }

      #endregion // Filesystem_Class_Shell32Info

      #region Filesystem_Class_VolumeInfo

      [TestMethod]
      public void Filesystem_Class_VolumeInfo()
      {
         Console.WriteLine("Class Filesystem.VolumeInfo()");

         DumpClassVolumeInfo(true);
         DumpClassVolumeInfo(false);
      }

      #endregion // Filesystem_Class_VolumeInfo

      #endregion Filesystem

      #region Network

      #region Network_Class_DfsXxx

      [TestMethod]
      public void Network_Class_DfsXxx()
      {
         Console.WriteLine("Class Network.DfsInfo()");
         Console.WriteLine("Class Network.DfsStorageInfo()");

         DumpClassDfsInfo();
      }

      #endregion // Network_Class_DfsXxx

      #region Network_Class_OpenConnectionInfo

      [TestMethod]
      public void Network_Class_OpenConnectionInfo()
      {
         Console.WriteLine("Class Network.OpenConnectionInfo()");

         if (!UnitTestConstants.IsAdmin())
             Assert.Inconclusive();

         DumpOpenConnectionInfo(UnitTestConstants.LocalHost);
      }

      #endregion // Network_Class_OpenConnectionInfo

      #region Network_Class_OpenResourceInfo

      [TestMethod]
      public void Network_Class_OpenResourceInfo()
      {
         Console.WriteLine("Class Network.OpenResourceInfo()");

         if (!UnitTestConstants.IsAdmin())
             Assert.Inconclusive();

         DumpClassOpenResourceInfo(UnitTestConstants.LocalHost, UnitTestConstants.LocalHostShare);
      }

      #endregion // Network_Class_OpenResourceInfo

      #region Network_Class_ShareInfo

      [TestMethod]
      public void Network_Class_ShareInfo()
      {
         Console.WriteLine("Class Network.ShareInfo()");

         string host = UnitTestConstants.LocalHost;

         Console.WriteLine("\n=== TEST ===");
         Console.Write("\nNetwork.Host.EnumerateShares() from host: [{0}]\n", host);

         int cnt = 0;
         UnitTestConstants.StopWatcher(true);
         foreach (ShareInfo share in Host.EnumerateShares(host, true))
         {
            Console.WriteLine("\n\t#{0:000}\tShare: [{1}]", ++cnt, share);
            UnitTestConstants.Dump(share, -18);
         }

         Console.WriteLine("\n{0}", UnitTestConstants.Reporter(true));

         if (cnt == 0)
            Assert.Inconclusive("Nothing was enumerated.");
      }

      #endregion // Network_Class_ShareInfo

      #endregion // Network

      #region OperatingSystem

      #region Class_OperatingSystem

      [TestMethod]
      public void Class_OperatingSystem()
      {
         Console.WriteLine("Class Win32.OperatingSystem()\n");

         UnitTestConstants.StopWatcher(true);

         Console.WriteLine("VersionName          : [{0}]", OperatingSystem.VersionName);
         Console.WriteLine("OsVersion            : [{0}]", OperatingSystem.OSVersion);
         Console.WriteLine("ServicePackVersion   : [{0}]", OperatingSystem.ServicePackVersion);
         Console.WriteLine("IsServer             : [{0}]", OperatingSystem.IsServer);
         Console.WriteLine("IsWow64Process       : [{0}]", OperatingSystem.IsWow64Process);
         Console.WriteLine("ProcessorArchitecture: [{0}]", OperatingSystem.ProcessorArchitecture);

         Console.WriteLine("\nOperatingSystem.IsAtLeast()\n");

         Console.WriteLine("\tOS Earlier           : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Earlier));
         Console.WriteLine("\tWindows 2000         : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Windows2000));
         Console.WriteLine("\tWindows XP           : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsXP));
         Console.WriteLine("\tWindows Vista        : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsVista));
         Console.WriteLine("\tWindows 7            : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Windows7));
         Console.WriteLine("\tWindows 8            : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Windows8));
         Console.WriteLine("\tWindows 8.1          : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Windows81));
         Console.WriteLine("\tWindows 10           : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Windows10));

         Console.WriteLine("\tWindows Server 2003  : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsServer2003));
         Console.WriteLine("\tWindows Server 2008  : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsServer2008));
         Console.WriteLine("\tWindows Server 2008R2: [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsServer2008R2));
         Console.WriteLine("\tWindows Server 2012  : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsServer2012));
         Console.WriteLine("\tWindows Server 2012R2: [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsServer2012R2));
         Console.WriteLine("\tWindows Server       : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.WindowsServer));

         Console.WriteLine("\tOS Later             : [{0}]", OperatingSystem.IsAtLeast(OperatingSystem.EnumOsName.Later));

         Console.WriteLine();
         Console.WriteLine(UnitTestConstants.Reporter());
      }

      #endregion // Class_OperatingSystem

      #endregion // OperatingSystem

      #endregion Unit Test Callers
   }
}


adidas Ultra Boost Uncaged Red - Men Shoes : Seasonal brand shoes on the line,50% discount!, Seasonal fashion shoes, stylish style,affordable!
Don't want to miss out on the adidas Ultra Boost Uncaged Red? We're not going to lie, this is going to be a difficult one to secure. After all, this Uncaged style has been causing a frenzy across social media since the first images were unveiled several months ago. Fortunately, we're providing all the info you need to give you the best chance of buying a pair.Follow our social media pages for up-to-date information on this release. As part of the collection, there will also be a grey model available. On the day of launch, we'll provide direct links to all available stockists for both. If you're one of the unlucky sneakerheads, we'll also be posting restock updates in the event of any new sizes coming in.The pair is dressed in a vibrant Red colourway. As with many coloured Primeknit designs, it takes on an almost gradient affect with darker shades coming through and black. This colour scheme is complimented with a black overlay to the rear. Adding some protection, it also showcases the Ultra Boost branding in gold. Finally, we have a white midsole underfoot which guarantees that unbelievable comfort.The adidas Ultra Boost Uncaged Red is scheduled to release on Wednesday 29th June via the following retailers.


text:
Q: How to save configuration path of property and value at once using c# I am working on an application where I need to save the ConfigurationPath and the value of the property into the database. Currently, if there are 3 properties in a class I need to save them separately I have to call the database to save changes for every property. I don't want to save it like this. Here is my existing code.
I want to achieve the whole KroneOptionsBase to be saved or updated in a single go using OptionPatterns.

public class KroneOptionsBase
{
    /// <summary>
    /// The configuration key used when binding to an IConfiguration instance.
    /// </summary>
    public static string RootConfigurationKey => ConfigurationPath.Combine("Partners", "Krone");
}

public class PartLocatorOptions : KroneOptionsBase
{
    /// <summary>
    /// The configuration key used when binding to an IConfiguration instance.
    /// </summary>
    public static string ConfigurationKey => ConfigurationPath.Combine(RootConfigurationKey, "PartLocator");

    /// <summary>
    /// If the part locator is enabled or not
    /// </summary>
    public bool? Enabled { get; set; }

    /// <summary>
    /// The list of manufacturer settings
    /// </summary>
    public IEnumerable<ManufacturerOptions>? Manufacturers { get; set; }
}

public class ManufacturerOptions
{
    /// <summary>
    /// The ASPEN-specific identity for
    /// the manufacturer.
    /// </summary>
    public int? Identity { get; set; }

    /// <summary>
    /// The Krone-specific brand code that
    /// corresponds to the manufacturer.
    /// </summary>
    public string? BrandCode { get; set; }

    /// <summary>
    /// The identity for the associated location.
    /// </summary>
    public int LocationIdentity { get; set; }
}

private async Task updateMainConfigurationAsync(PartLocatorOptions configuration,
    CancellationToken cancellationToken)
{

    try
    {
        var rootKey = KroneOptionsBase.RootConfigurationKey;
        var partLocatorRootKey = ConfigurationPath.Combine(rootKey, $"PartLocator");

        if (_options.NotifyOnSuccess != configuration.NotifyOnSuccess)
        {
            await updateDatabaseLevelConfigurationAsync(partLocatorRootKey,
                                                       nameof(configuration.NotifyOnSuccess),
                                                       configuration.NotifyOnSuccess ?? false,
                                                       cancellationToken);

        }
    }
    finally
    {
        _logger.LogMethodEnd();
    }
}

private async Task updateDatabaseLevelConfigurationAsync(string configurationPath,
        string key,
        object configurationLine,
        CancellationToken cancellationToken)
{
    try
    {
        if (configurationLine != null)
        {
            var configurationResult = await _configurationRepository
                    .GetAspenDatabaseItemAsync(_databaseIdentity,
                        ConfigurationPath.Combine(configurationPath, key),
                        cancellationToken);

            if (configurationLine != null && configurationLine.ToString() != configurationResult?.Value)
            {
                if (configurationResult == null)
                {
                    configurationResult = new AspenDatabaseConfigurationItem
                    {
                        Key = ConfigurationPath.Combine(configurationPath, key),
                        DatabaseIdentity = _databaseIdentity,
                        Value = configurationLine.ToString()
                    };
                    _configurationRepository.AddConfigurationItem(_databaseIdentity, configurationResult);
                }
                else
                {
                    configurationResult.Value = configurationLine.ToString();
                    await _configurationRepository.UpdateAspenDatabaseItemAsync(configurationResult, cancellationToken);
                }
            }
        }
    }
    finally
    {
        _logger.LogMethodEnd();
    }
}

For example in PartLocatorOptions I need to save the value of Enabled I have to get the configuration path like Partners:Krone:PartLocator:Enabled and add it as KeyName and get the value of Enabled and add it as ValueData.
I am also facing one more issue, for example, it contains manufacturer collection so what will be the solution for this part as you can see I have written a separate method to add the manufacturer list to the database. The database entries look like this. See the below image

A: You can try this one
using Microsoft.Extensions.Configuration;

...

private async Task updateMainConfigurationAsync(PartLocatorOptions configuration, CancellationToken cancellationToken)
{
    try
    {
        var rootKey = KroneOptionsBase.RootConfigurationKey;
        var partLocatorRootKey = ConfigurationPath.Combine(rootKey, "PartLocator");

        // Bind the configuration data to the PartLocatorOptions instance
        IConfigurationSection section = _configuration.GetSection(partLocatorRootKey);
        section.Bind(configuration);

        // Update the database with the configuration data
        await updateDatabaseLevelConfigurationAsync(partLocatorRootKey, configuration, cancellationToken);
    }
    finally
    {
        _logger.LogMethodEnd();
    }
}

private async Task updateDatabaseLevelConfigurationAsync(string configurationPath,
    PartLocatorOptions configuration,
    CancellationToken cancellationToken)
{
    try
    {
        // Save the Enabled property
        await updateDatabaseLevelConfigurationAsync(configurationPath, "Enabled", configuration.Enabled ?? false, cancellationToken);

        // Save the ManufacturerOptions list
        if (configuration.Manufacturers != null)
        {
            for (int i = 0; i < configuration.Manufacturers.Count(); i++)
            {
                var manufacturerPath = ConfigurationPath.Combine(configurationPath, $"Manufacturers:{i}");
                await updateDatabaseLevelConfigurationAsync(manufacturerPath, "Identity", configuration.Manufacturers.ElementAt(i)?.Identity ?? 0, cancellationToken);
                await updateDatabaseLevelConfigurationAsync(manufacturerPath, "BrandCode", configuration.Manufacturers.ElementAt(i)?.BrandCode ?? "", cancellationToken);
                await updateDatabaseLevelConfigurationAsync(manufacturerPath, "LocationIdentity", configuration.Manufacturers.ElementAt(i).LocationIdentity, cancellationToken);
            }
        }
    }
    finally
    {
        _logger.LogMethodEnd();
    }
}

private async Task updateDatabaseLevelConfigurationAsync(string configurationPath,
    string key,
    object configurationLine,
    CancellationToken cancellationToken)
{
    try
    {
        if (configurationLine != null)
        {
            var configurationResult = await _configurationRepository.GetAspenDatabaseItemAsync(_databaseIdentity,
                ConfigurationPath.Combine(configurationPath, key),
                cancellationToken);

            if (configurationLine.ToString() != configurationResult?.Value)
            {
                if (configurationResult == null)
                {
                    configurationResult = new AspenDatabaseConfigurationItem
                    {
                        Key = ConfigurationPath.Combine(configurationPath, key),
                        DatabaseIdentity = _databaseIdentity,
                        Value = configurationLine.ToString()
                    };
                    _configurationRepository.AddConfigurationItem(_databaseIdentity, configurationResult);
                }
                else
                {
                    configurationResult.Value = configurationLine.ToString();
                    await _configurationRepository.UpdateAspenDatabaseItemAsync(configurationResult, cancellationToken);
                }
            }
        }
    }
    finally
    {
        _logger.LogMethodEnd();
    }
}

redpajama_set_name: RedPajamaStackExchange


BANGALORE: Four young writers from different parts of India on Sunday made use of the Bangalore Literary Festival to emphasize the primacy of bhasha by reciting their literary works in their languages, and proved that bhasha pride is not about chauvinism but a cultural context to literature.
The session was Voices of India: Young litterateurs of Bhasha.
Jayanth Kodkani, senior editor, The Times of India, Bangalore, who moderated the session, said in his introduction that the focus was on the decline of bilinguism and multilinguism in urban India, particularly among the middle class. "Bhasha is our pride. We are rich with bhasha. Bhasha is about texture given to culture," he said.
Speaking on the literary atmosphere in Kashmir, Farooq, a teacher in Langate in Handaware tehsil of Kupwara district in the valley, said many youngsters are focusing on subjects like romance, Kashmiri culture and the present situation.
"Nighat Sahab, who is under 30 years, Nisar Azam and Shabnum Gulzar show promise as future writers. They write mostly in Kashmiri and Urdu," said Farooq, who recited two poems in Kashmiri and later their English translations. His Urdu poem (Reflection in English) excellently captures the childhood days of Kashmiri — his grandmother, how he saw nature, Ramzan, farmers and music of love as a child.
Arindam Borkataki, an Assamese writer, thanked writer Chandrasekhara Kambar for speaking in Kannada and Gulzar for speaking in Urdu at the inaugural of the festival, and explained the importance of bhasha and the struggle to establish themselves as writers. He also recited an Assamese poem.


text:
Sustainable Skyline: by Steven Yoder & Comstock's
New high rises coming to Sacramento will test the limits of what's possible in commercial-building efficiency
When it comes to low-carbon construction design, flashy new products get the most attention: solar roof tiles, algae-growing building materials, solar tracking mounts that follow the sun, skyscraper-mounted wind turbines and so on. But on commercial buildings, what actually cuts carbon the most are its plain-vanilla basics, known as the passive elements. Those include the materials used in the walls, windows and roof, and how the building is oriented – for example, when planning a rectangular building, it's best if the long side faces south.
A really efficient exterior means the mechanical systems like the heating, cooling and lighting don't have to work as hard, says Ray Nalangan, a senior architect with SMUD
Two new State buildings in downtown Sacramento will push the envelope for what's possible in sustainability, utilizing passive elements and smart planning in the process. And those projects will spin off valuable lessons for other developers and building owners as they plan new projects or retrofit existing structures. New construction efforts offer a big advantage since energy efficiency can be incorporated from the design stages, making these two building projects prime candidates for smart planning.
The new structure at 1215 O Street will house up to 1,150 employees from the three State agencies. And the P Street building will sit on the lot between 7th and 8th and O and P streets. At 20 stories, it will be more than twice as big as the O Street strcuture and be home to about 3,500 employees from eight agencies along with an onsite child-care facility for up to 120 children.
The State of California has set a high bar for how these buildings will use energy. In its specifications for O Street. the State's Department of General Services required an "energy use index" of 28. That index measures the energy use per square foot, something like gallons per mile for a car. For most buildings, it's 80-100, says Nick Docous, board chairman and civic practice lead at Lionakis, which is a partner on the O Street project. But the O Street building will have a rock-bottom EUI of 23. Its passive elements will be a big reason why. The structure will run lengthwise east to west and be made of poured-in-place concrete, says Docous.
Concrete retains energy better, so once a concrete structure gets to the right temperature, it stays there longer than those of steel or fiberglass, Nick Docous
On the southern exposure, a fixed suncreen called a brise soleil will open and close to let the building collect heat when it's cold and shade it when it's warm. But it's the solar mechanical elements that will shrink these buildings' carbon footprints to zero. Under an agreement between DGS and SMUD, the buildings will get some of their electricity needs met by offsite SMUD-generated solar and some from solar panels on their own roofs. Inside, other mechanical elements will crank up how efficiently that energy is used.
For example, "chilled-beam" air treatment systems in many ceilings will take rising warm air, run it over a chilled-water coil and drop it back down as cool air, says Chris Barker, engineering department manager at Airco Mechanical, a partner on the O Street project. That system allows the office space to stay at the right temperature with far less piped-in air, he says. State energy requirements mean private developers and other contractors will be watching with interest.
The California Energy Efficiency Strategic Plan requires all new commercial construction to be zero net energy by 2030 and half of all commercial buildings to be retrofitted for ZNE by that year
(ZNE means that all of a building's energy needs are met by renewable resources.) Half of new state-owned buildings starting design after 2020 and all new state-owned buildings and major renovations designed after 2025 must be constructed as ZNE. Dave Pixley, president at Applied Energy Innovation in Folsom says that as companies think about how to get there, they should consider equipment that could cut how much power their buildings need in the first place. Consider transformers, which take electricity coming into a building and convert it to lower voltages for the equipment and systems inside. Most transformers are inefficient, Pixley says. They are necessarily massively oversized to make sure they have ample capacity. But at the low loads they handle, they run at only 80-85 percent efficiency.
Higher-end transformers run far more efficiently at those loads and can cut 5-8 percent off electricity costs
And a power-conditioning technology that his company sells is designed to improve the quality of the electrical signal coming into a building – signal quality can be affected by many things, among them being near the end of an electrical-line run or operating lots of high-end loads like motors, he says. The signal-regularizing equipment, called a universal shunt efficiency system, can deliver 5 to 20 percent savings on electricity in higher cost utility regions, Pixley says.
All of that means there are many routes for getting to ultra-efficient commercial structures. Nalangan is excited by the O and P Street projects because they'll showcase the most forward-thinking ideas in commercial-building sustainability and generate data critical to designing more low-carbon buildings down the road. Nalangan, who spent 14 years at private companies before joining SMUD, says that when he was in private practice,
You'd have great ideas that were hard to move beyond the design phase because there were constraints. These projects will make us a smarter organization.
Steven Yoder writes about business, rel estate and criminal justice. His work has appeared in The Fiscal Times, Salon, The American Prospect and elsewhere. On Twitter @syodertweet and at stevenyoder.net. Thank you to Steven and Comstock's Magazine for this article which was published as part of the ACRE/BOMA supplement in the April issue, print version, on newsstands now.

redpajama_set_name: RedPajamaCommonCrawl


Nike BOYS Athletic Pants Size 6 Navy/Yellow Joggers with side pockets!
Athletic Boys Youth Size 6-7 Black Gray Tricot Pants Athletic Stripe.
Reebok Boys Basketball Athletic Training Pants Elastic Waist & Side Snaps NWT .


text:
Myth-Busters
Sunil Grover returns to TV with new comedy; proceeds will go towards Covid relief
ByAkash BhatnagarAkash Bhatnagar / Updated: Aug 7, 2020, 08:17 IST
Sunil Grover back with new comedy; proceeds to go for Covid relief.
Sunil Grover is all set to return with a new comedy show on Star Bharat, Gangs of Filmistan. The actor believes that in the current scenario, people desperately need some laughs. "I don't know how to make a vaccine, but I know how to entertain and that's what I aim to do," he asserts, informing that the show will air five days a week and while it will have some Bollywood sketches, there will be no celebrity guests or a 'live' audience.
Untitled Carousel
Rana Daggubati and Miheeka Bajaj's haldi ceremony was performed in Hyderabad in the lead up to their August 8 wedding
On May 12, Rana Daggubati announced on social media that he has virtually proposed to girlfriend Miheeka Bajaj in the midst of a pandemic and she had said "yes".
Sunil plays a don who wants to be entertained so people come and perform for him. "For the first time, I will be sitting on the other side and this way, will automatically observe social distancing," he quips, pointing to a talented ensemble cast, including Shilpa Shinde, Siddharth Sagar, Sanket Bhosale, Sugandha Mishra, Paritosh Tripathi and Jatin Suri. "I will not be revisiting any of my iconic characters, like Gutthi and Mashoor Gulati. I come with a new character, but the same old intentions. I hadn't planned on doing a show, but the offer was too good to pass up."
When Archana Puran Singh and Parmeet Sethi eloped
This weekend, Kashmera Shah and Priyanka Sharda, the wives of team members Krushna Abhishek and Kiku Sharda, along with regular guest Archana Puran Singh's husband, Parmeet Sethi, will share some secrets with Kapil Sharma.
The actor's last two collaborations with Star—Mad in India and Kanpur Wale Khuranas—failed to impress, but that doesn't faze him. "Our forte is to make people laugh, if we don't do that in these times, what's the use of this gift! If I were to do a murder mystery instead, it would only scare people in a bad way," he points out.
They begin shoot next week and all his earnings from the show will go into relief work for those suffering due to the pandemic.
Sunil Grover aka Gutthi accepts the black and white challenge, check his post here
Amid the COVID-19 pandemic, a new Instagram challenge has kicked off in order to spread a message about female solidarity and empowerment. Now, actor-comedian Sunil Grover has given a hilarious twist to this new trend as he shared his black-and-white picture of one of his most-admired characters Gutthi.
Taarak Mehta Ka Ooltah Chashmah: Exclusive photos from the first episode post lockdown
All-new episodes of Taarak Mehta Ka Ooltah Chashmah
Taarak Mehta Ka Ooltah Chashmah, one of the most popular sitcoms on Indian television, is all set to air the new episodes of the show post lockdown from Wednesday (July 22) after a hiatus of four months. The cast and crew came together a couple of weeks ago and resumed shooting in the 'new normal', ensuring all the safety measures and precautions were put in place. Now, before the fans of the show get to know what is in store for them in the coming days, Mirror has got its hands on some exclusive pictures and stills of the most-loved characters from the first episode of TMKOC post lockdown.
Jethalal is back!
Dilip Joshi, who plays the iconic character of Jethalal Gada on the show was seen in a joyous mood as the show resumed after such a long time. The 52-year-old had earlier told Mirror that even though the COVID-19 scare exists in the minds of the entire unit, it feels good to be back at work. "Asit Bhai ensures that all the SOPs are strictly followed on the set. He has gone out of the way to make shooting safe for us, including a sanitisation tunnel, doctors on set to monitor temperature and oxygen levels, a UV Ray machine to sanitise jewellery and other equipment. We have to learn to live with the fear because the virus won't disappear in a hurry," he averred.
Meet the Gada family
In one of the stills, the Gada family, aka Jethalal, his 'Bapuji' and his son Tipendra (Tapu) can be seen holding their hands and celebrating their return on the small screen. Joshi had said that the makers have tweaked the script so that only a limited number of actors participate in a particular scene. "We are shooting with a maximum of four actors per episode. We have cut down on the crew too," he explained, promising that the popular show will have episodes which build on the awareness of precautions that are crucial in these trying times.
Challenges of shooting amid a pandemic
Joshi had also said that while it feels good to be back on the familiar set, it is difficult for the actors to evoke laughs when the situation around is tense due to a pandemic. "It's tough, but we are trying our best. You have to forget everything in front of the camera and let yourself be transported to a different world. We keep improvising on the set," he shared. "Actors, in particular, stand the maximum risk of being exposed to the virus while shooting as they can't wear masks in front of the camera. So, we are exposed to the droplets, but you must have faith in God," he added.
Mr and Mrs Bhide are back too!
Aatmaram Tukaram Bhide and his wife Madhavi Bhide were also snapped shooting for a particular scene and looked cheerful as ever. Producer Asit Modi had revealed that they had resumed the shoot with Tapu Sena as they wanted to keep the first day a little easy. "We started with the Tapu Sena as we wanted to keep things slow and easy on the first day, given the fear of the virus. We will be shooting almost every day now and the other actors will join in as and when required, once they feel confident enough to get back to the set," he had said.


There are few things in life more shameful than bashing the wife of a fallen soldier for simply having her husband honored by the current Commander-in-Chief.
Democrats could taste blood in the water after Trump honored fallen Navy SEAL Ryan Owens and his wife Carryn, and they didn't hesitate to attack. Unfortunately for them, this wasn't about to be tolerated by Mary Katharine Ham, who took a few Tweets to send hateful liberal Debra Messing back to her place.
It didn't take long for Democrats to begin attacking Carryn Owens, including celebrity Debra Messing.
What the President did w Owen's widow was capital P Presidential. It was the single most extraordinary moment I've seen from Trump – by far.
But Twitter wasn't about to let her heartless comments go unnoticed.
you are negative and think everything is horrible! She represented her husband and was proud of her husband! You r divisive!
CNN contributor Mary Katharine Ham chimed in with a wise-beyond-her-years rebuke of this horrible message.
Maybe a SEAL wife knows exactly what she's doing & doesn't need you to explain it to her. Maybe she needs things you don't know much about.
Maybe all that is more important than your angst about which president is involved & how. Just bc she's crying doesn't mean she's a victim.


text:
Otto von Kerpen  a Német Lovagrend második nagymestere. A Rajna vidékéről származott. Családnevét a Gilesheim melletti Kerpenben levő kastélyról kapta.
Kereszteslovagként került a Szentföldre, ahol csatlakozott az Acre-ban (Akkó) egy betegápoló testvériségből alapított Német Lovagrendhez, s annak 1200-tól vezetője lett. Elődje a nagymesteri székben Bassenheimi Walpot Henrik volt.

1208-ban halt meg Acre-ban.

A Német Lovagrend nagymesterei
1208-ban elhunyt személyek

redpajama_set_name: RedPajamaWikipedia


Among a lot of tricked out slot machines sometimes gamblers want to find something simple and interesting. One of these is the "Crazy Gems" slot machine, released on the 13th of May, 2016 by the Booongo Gaming provider. Despite the simplicity, it is very easy for beginners and has an interesting storyline, it can be played for free without registration and SMS. A simple but elegant "Crazy Gems" slot will allow casino players to feel the luxury of staying in a cave of precious stones. The rules of the slot machine turned out to be quite unusual, due to the possibility of paying prizes in the center or sides of the screen in cases of forming combinations of three or more identical symbols.
To turn the virtual treasures of the "Crazy Gems" slot machine into real money, users must choose the optimal strategy variant. The main source of information is hidden in RTP return rates and volatility level, which determines the size of awards and the frequency of formation of lines with a win.
The second feature continues the first and allows free rotation at the same level of monetary units with the Double Symbol function. If the Re-spin round brings another additional feature activator to the indicated positions of the online slot, the replay will start again.
A large number of shares and tournaments in this slot.
All adventures will take place in the cave. Each stone has a certain value and value. The slot also has the option of a free spin, which allows you to generate a certain number of free spins. When activated, the player gets the opportunity to get more wins and crank several new combinations. The mechanics of the machine are fairly simple and with the proper skill it can bring a certain amount of money to the client. After all, turning virtual winnings into real ones is entirely possible, it is only important to know which systems are recommended to use.
Prizes for spin are paid in the event that it is possible to collect a minimum of 3 identical symbols in a continuous sequence. They are counted not only in a straight line, but also in other chains. The layouts of the winning combinations and the value of each are shown in the payout table, which is opened with the "i" key. The most insignificant signs – cards, will bring up to 900 credits for each delivered. Crystals are valued more, in order of decreasing remuneration, they are arranged as follows: multi-colored (coefficient up to x2500), orange (up to x2000), green (up to x1500) and blue (up to x1000). On the 2nd, 3rd and 4th reels there may be a bonus symbol Star Gem. Causes other images to split and gives a second spin. Split gems will combine in incredible combinations, now a maximum of 8 characters! "Crazy Gems" slot is a game where the risk game is not provided.
The 5-reel slot offers a combination of 10 play lines. There is no opportunity to change their amount of opportunity in "Crazy Gems". The only setting is the bet size, adjust the amount with the arrows in the desired direction. On the right hand side, you will see the winning amount, just below the current balance. In the center there is a round key for start, to the left of it a button for maximum bet, on the right – a key for starting auto mode, in which the reels will rotate continuously. That's all the settings. To get comfortable, try to play for free, in online demo mode.
When a multi-colored star appears on the second, third or fourth drums of a special symbol, the player receives two types of bonuses. First of all, all the symbols on the drum become double, that is, they are counted not as one, but as two. Then free re-spin begins. Any symbols dropped on one drum with a star – remain double. If a star appears again when the spawn is repaired, the player receives an additional re-spins. They continue until special symbols appear on the designated drums. In the case of a resp, the linear rate assigned to the last rotation in the main game is taken into account. Additional multipliers for winning combinations are not present.
A multi-colored crystal – 50, 300, 750, 800, 1,000, 2,500.
No difficulties in the game process in "Crazy Gems" should arise. To do this, it is enough to register in one of the licensed casinos, enter your details and start the game. Despite the fixed number of payments and the installed line, the machine allows you to raise good amounts. To do this, you need to know certain combinations and have a little luck with you. The most important thing to remember is that this machine belongs to the gaming machine, which means that it is not possible to earn money on it. After all, often even after a dozen attempts on the balance, nothing is added. The player must be accompanied by some element of luck, in the absence of which to use the slot is not recommended and you should try your luck the next day. You can withdraw your winnings by any convenient method, since the number of standard and electronic payment systems is quite large and each player can choose independently the most interesting and profitable method of deducing the resulting winnings, if any.
One can run the drums in both manual and automatic modes in "Crazy Gems" slots game. One spin starts when you press the Spin key located in the center of the control panel. Automatic rotation starts after the player has selected the desired number of spins in the Auto Game drop-down menu. The player is able to change the speed of the reels scrolling. This does not affect the drop-down symbols, but only accelerates the animation. The switch is located under the Auto Game key.
The "Crazy Gems" slot machine appeared in online casino gambling halls thanks to the efforts of the specialists from Booongo. This brand is in great demand, because under its name the most high-quality and interesting gaming devices are produced. "Crazy Gems" slot will delight you with spectacular graphics, colorful themes and eye-popping payments. It's worth noting that it's very easy to play it, so everyone will like the slot. A simple but elegant slot "Crazy Gems" by Booongo Gaming will allow players to feel the luxury of staying in the cave of precious stones. For beginners, the demo version of Crazy Gems is perfect. After playing in it and having received your welcome bonuses, you will quickly figure out what's what. The rules of the slot machine turned out to be quite unusual, due to the possibility of paying prizes in the center or sides of the screen in cases of forming combinations of three or more identical symbols. The search for the gems of the "Crazy Gems" slot machine will go under the ground, where the drums with pictures of nuggets and card denominations rotate.


Learn the basics of chemistry and chemical reactions with this essential chemistry set. Investigate the properties of acids and bases. In this kit you'll discover some revealing pH Experiments. This box kit includes the necessary equipment to investigate Acids and Bases. Includes Ein-O's I Know Guide. For Ages 8 and up with adult supervision.
With this amazing box science kit, you're future scientist will explore the relationship between organisms and the environment in the world's coldest regions! Experiment and study what threatens the balance of lives in the icy zone. Includes Ein-Os I Know Guide!
Discover the relationships between organisms and the environment in scorching deserts. Conduct a collection of interesting science experiments to explore how plants and animals adapt to the hot and dry desert landscape. Learn about the fascinating features of natural ecosystems!
Build your own electronic musical instrument Discover and express your musical talent Requires 2 x "aa" batteries, not included.


text:
Home Faith Servant: a biblical mandate for the importance of service
Servant: a biblical mandate for the importance of service
By William Ackland -
"If you have a desire to be great among your companions then you are to be their servant" Matthew 20:26 (The Gift).
The concept of servanthood is strongly presented in Scripture. There are approximately 1600 references in the Bible to the words servant, servants, serve, served, serves, service, servile serving and servitude.
The derivations of the word "serve" are interesting and varied, but generally follow a fairly similar meaning, though used in different contexts over the centuries.
For example, in the late 12th Century the word meant, "to render habitual obedience to", also, "to minister, give aid, give help". In the Old French servir, interestingly, means "to show devotion to, to set table, serve at table. This is an echo of Acts 6:2, where one of the 12 disciples stated, "It is not desirable that we should leave the word of God and serve tables." Other origins from Etruscan, Proto-Italian and general English usage through the 13th to the 16th centuries have the same general meaning as we understand the word today.
Christ made very clear what He meant by the word servant. Matthew records the incident when the mother of the sons of Zebedee, James and John, came to Jesus and asked that her two sons be placed in positions of high honour in His kingdom, sitting next to Christ on His right and on His left. What may seem an outrageous request to us was accepted by Jesus as a genuine request by a mother. He directed His answer to the brothers, who by this time were probably standing rather sheepishly before Him, probably hearing the murmuring of the other disciples.
Jesus asked them if they were able to drink the cup He was about to drink and be baptised with the baptism He would endure. The fact that they replied, "We are able," shows that Christ was directing His answer to them and not to their mother.
We then come to the key point of this incident when Christ stated in clear terms, "who ever desires to be great among you, let him be your servant" (NKJV).
One of the character flaws that soon developed after the entrance of sin was the assertion of one's self at the expense of others. This may not apply to every person, but it is part of the character and personality of many people.
To be selfless, like Christ, is an aim that all Christians should have.
Faith without service?
Luther was a towering figure in the great Protestant Reformation and, along with other great men before and after him, he changed the whole landscape of the religious world.
However, Luther had his weaknesses, as we all do. In much of his life and ministry, he did not like the Jews (to put it mildly). You might be surprised at what he said about the Jews and what should happen to them. He was also contemptuous of the book of James, calling it a straw-epistle compared to books written by John, Paul and Peter.
Luther's main dislike for James' book is that James highlighted the truth that faith without "works" is not faith at all. In fact, James challenges people by saying that they should try to show their faith without works, and he would show his faith by his works of service.
Surely Luther would not have been opposed to the concept of service. After all, penance that he had practised diligently may be described as service in the extreme, though ill-directed. Maybe this explains his aversion to James; if he equated these sort of acts from his past, to works.
Jesus' powerful statement recorded in Matthew 25 shows just how He will separate the good from the bad, the sheep from the goats, at His second coming.
These challenging verses suggest that Jesus judges people by what they have done, and also by what they have not done.
Jesus does not bring prayer into the equation. He does not say, "If you prayed for the sick and those in prison etc, then you may enter into My kingdom." Rather, if you knew someone was sick and did not visit them to comfort them, then you are a goat, plain and simple, whether you prayed for them or not.
Of course, prayer is good—it is essential for the Christian—but as James might say, Fine, you prayed for someone but did you do anything to help them in their distress?
Model servant
There is a very fine example of a true servant recorded very early in the book of Genesis. Isaac was 40 years of age and Abraham decided, as fathers did in those days, that it was about time that his son and heir married. He was adamant that Isaac's wife should not be one from among the Canaanite people but should be chosen from among his relatives, who still mainly resided in and around Haran.
Eliezer, originally from Damascus, was Abraham's chief servant. He was charged with finding a wife for Isaac from among Abraham's relatives. He was a prime example of someone who united doing with praying, for not only did he obey his master—taking all the supplies he needed, 10 camels and sufficient under-servants—but he also prayed fervently that God would give him success on his mission for his master. He asked God that the woman meeting God's approval would meet two conditions. First, she would give Eliezer a drink from her pitcher when he asked for a drink, but she would also offer to water the camels.
Imagine how grateful and elated Eliezer must have felt in having a positive answer to his prayer on both counts. Here was this young woman, who is described as "very beautiful to behold" destined to be the wife for Isaac.
Eliezer's mission was now a success, for when the party returned and were not far from Abraham's tents, at Beer Lahai Roi, Rebekah alighted from her camel, met the one who would be her husband, who loved her at first sight and who then took her into his mother's tent to be married.
There are many other examples in Scripture of faithful servants who were not only prayers, but also doers.
It was Jesus Himself who described His mission to the world in this way:
"For even the Son of Man did not come to be served but to serve, and to give His life a ransom for many" Mark 10:45 (NKJV).
William Ackland is retired in Cooranbong, NSW, and has written six books.
Isaac and Rebekah
James and John
Melody Mason talks prayer and Bible study
Jeff Scoggins talks Bible study and good stories
Patient endurance


This traditional size Coffee Mug holds approximately 14 ounces and is approx. 4" tall. Dishwasher and microwave safe! Shown in Fred's glaze.
Click the button below to add the Coffee Mug 14 oz. approx. to your wish list.