public static string LocalAppData(PlatformID platform, string organization, string product)
        {
            if (organization == null)
                throw new ArgumentNullException(nameof(organization));
            if (product == null)
                throw new ArgumentNullException(nameof(product));
            if (product.Length == 0)
                throw new ArgumentException(nameof(product) + " may not have zero length");

            switch (platform)
            {
                case PlatformID.Win32NT:
                    return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
                        ToUpper(organization), ToUpper(product));
                case PlatformID.MacOSX:
                    return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal),
                        "Library", "Application Support", ToUpper(organization), ToUpper(product));
                case PlatformID.Unix:
                    var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
                    if (organization == "")
                    {
                        return Path.Combine(homeDirectory, ToDotLower(product));
                    }
                    else
                    {
                        return Path.Combine(homeDirectory, ToDotLower(organization), product.ToLower());
                    }
                default:
                    throw new PlatformNotSupportedException($"PlatformID={platform}");
            }
        }

 public OSFilterAttribute(FilterActions action, PlatformID osType, FilterRules rule, string osVersion)
 {
     Action = action;
     OSType = osType;
     Rule = rule;
     Version = osVersion;
 }

		Assembly GetPlatformAssembly(PlatformID platformId)
		{
			var assemblyName = string.Empty;
			var currentAssembly = Assembly.GetExecutingAssembly();
			
			var uri = new Uri(currentAssembly.CodeBase);
			var directory = Path.GetDirectoryName(uri.AbsolutePath);
			
			
			switch( platformId )
			{
			case PlatformID.Unix: 
				assemblyName = "Forseti.OSX";
				break;
			case PlatformID.Win32NT:
				assemblyName = "Forseti.Windows";
				break;
			}
			assemblyName = string.Format ("{0}/{1}.dll",directory,assemblyName);
			
			if( System.IO.File.Exists(assemblyName) ) 
				return Assembly.LoadFile (assemblyName);
			
			return typeof(MainRegistry).Assembly;
		}

 public void Platform_Unsupported(PlatformID platform)
 {
     // Arrange
     // Act
     // Assert
     Assert.Catch<PlatformNotSupportedException>(() => LibraryLoaderFactory.Create(platform));
 }

 public ReadFileAttribute(PlatformID platformID,String file, String regex = null)
 {
     this.PlatformID = platformID;
     File = file;
     if (regex != null)
         Regex = new Regex(regex);
 }

 public ShellCmdAttribute(PlatformID platformID, String program, String arguments, String regex)
 {
     this.PlatformID = platformID;
     this.Program = program;
     this.Arguments = arguments;
     this.Regex = new Regex(regex);
 }

		public OperatingSystem(PlatformID platformID, Version version) {
			if (version == null) {
				throw new ArgumentNullException("version");
			}
			this.platformID = platformID;
			this.version = version;
		}

 public OperatingSystem(PlatformID platform, Version version)
 {
   Contract.Requires(platform >= PlatformID.Win32S)
   Contract.Requires(platform <= PlatformID.MacOSX)
   Contract.Requires(version != null);
   Contract.EnsuresOnThrow<ArgumentException>(true, "platform is not a PlatformID enumeration value.")
   Contract.EnsuresOnThrow<ArgumentNullException>(true, "version is null.")
 }

 public static void Ctor(PlatformID id, string versionString)
 {
     var os = new OperatingSystem(id, new Version(versionString));
     Assert.Equal(id, os.Platform);
     Assert.Equal(new Version(versionString), os.Version);
     Assert.Equal(string.Empty, os.ServicePack);
     Assert.NotEmpty(os.VersionString);
     Assert.Equal(os.VersionString, os.ToString());
 }

        private static void CreateSilverlightSequence(IList<UnitTestTask> sequence, IUnitTestLaunch launch, UnitTestManager manager, PlatformID silverlightPlatform)
        {
            var silverlightRun = launch.GetOrCreateSilverlightRun(silverlightPlatform);

            sequence.AddSilverlightUnitTestTask(silverlightPlatform, manager);
            sequence.RemoveAssemblyLoadTasks();

            silverlightRun.AddTaskSequence(sequence);
        }

		public OperatingSystem (PlatformID platform, Version version)
		{
			if (version == null) {
				throw new ArgumentNullException ("version");
			}

			_platform = platform;
			_version = version;
		}

        protected override IEnumerable<string> GetReferencedAssemblies(PlatformID platformId)
        {
            foreach (var assembly in base.GetReferencedAssemblies(platformId) ?? Enumerable.Empty<string>())
            {
                yield return assembly;
            }

            yield return typeof(NotNullAttribute).Assembly.Location; // add reference to the annotations assembly
        }

    //google has been removed as we cannot get the picture without authenticating ourselves first.

    public static void GetProfilePicture(Action<Texture2D> callback, PlatformID platformID, string platformUserID)
    {
        GameObject profilePicPacket = new GameObject("ProfilePicPacket");

        ProfilePic pic = profilePicPacket.AddComponent<ProfilePic>();

        pic.callback = callback;

        pic.GetProfilePicture(platformID, platformUserID);
    }

        public static ILibraryLoader Create(PlatformID platform)
        {
            if(platform == PlatformID.Win32NT)
                return new WindowsLibraryLoader();

            if(platform == PlatformID.MacOSX || platform == PlatformID.Unix)
                return new UnixLibraryLoader();

            throw new PlatformNotSupportedException();
        }

        private static string GetOSName(PlatformID platformId)
        {
            switch (platformId)
            {
                case PlatformID.Win32Windows:
                    return "Windows";

                case PlatformID.Win32NT:
                    return "Windows NT";
            }
            return platformId.ToString();
        }

        public Proxy(string path)
        {
            _PlatformID = Environment.OSVersion.Platform;

            if (_PlatformID == PlatformID.Unix)
            {
                _Invoke = new SoInvoke(path);
            }
            else
            {
                _Invoke = new DllInvoke(path);
            }
        }

    IEnumerator GetProfilePic(PlatformID platformID, string platformUserID)
    {
        string url = urlSocialPlay + "?PID=" + (int)platformID + "&PUID=" + platformUserID;

        WWW www = new WWW(url);
        yield return www;

        if (callback != null)
            callback(www.texture);

        //Event sent, lets destroy it.
        Destroy(gameObject);
    }

 internal OperatingSystem(PlatformID platform, System.Version version, string servicePack)
 {
     if ((platform < PlatformID.Win32S) || (platform > PlatformID.MacOSX))
     {
         throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", new object[] { (int) platform }), "platform");
     }
     if (version == null)
     {
         throw new ArgumentNullException("version");
     }
     this._platform = platform;
     this._version = (System.Version) version.Clone();
     this._servicePack = servicePack;
 }

        public static UnitTestRun GetOrCreateSilverlightRun(this IUnitTestLaunch launch, PlatformID silverlightPlatform)
        {
            var runs = launch.GetRuns();
            var silverlightRun = runs.Values.FirstOrDefault(run => run.GetSilverlightPlatformVersion() == silverlightPlatform.Version);

            if (silverlightRun == null)
            {
                var runtimeEnvironment = new RuntimeEnvironment { PlatformType = PlatformType.x86, PlatformVersion = PlatformVersion.v4_0 };
                silverlightRun = new UnitTestRun((UnitTestLaunch)launch, runtimeEnvironment);
                runs.Add(silverlightRun.ID, silverlightRun);
            }

            return silverlightRun;
        }

        internal OperatingSystem(PlatformID platform, Version version, string servicePack) {
            if( platform < PlatformID.Win32S || platform > PlatformID.Unix) {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)platform),
                    "platform");
            }

            if ((Object) version == null)
                throw new ArgumentNullException("version");

            _platform = platform;
            _version = (Version) version.Clone();
            _servicePack = servicePack;
        }