public void AppendWarningTest(ConfigStatus.ErrorLevel initialLevel)
{
int initialLevelNum = Array.IndexOf(_sortedLevels, initialLevel);
int warningNum = Array.IndexOf(_sortedLevels, ConfigStatus.ErrorLevel.Warning);
int newLevelNum = Math.Max(initialLevelNum, warningNum);
ConfigStatus.ErrorLevel newLevel = _sortedLevels[newLevelNum];
string initialMessage = "Message init";
string warningMessage = "Warning message";
ConfigStatus status = StatusBySeverityLevel(initialLevel, initialMessage);
status.AppendWarning(warningMessage);
Assert.That(status.SeverityLevel, Is.EqualTo(newLevel));
Assert.That(status.IsOk, Is.EqualTo(false));
Assert.That(status.IsWarningLevel,
Is.EqualTo(newLevel == ConfigStatus.ErrorLevel.Warning));
Assert.That(status.IsErrorLevel, Is.EqualTo(newLevel == ConfigStatus.ErrorLevel.Error));
string[] errorMessages = GetMessagesForLevel(ConfigStatus.ErrorLevel.Error,
new[] { initialLevel, ConfigStatus.ErrorLevel.Warning },
new[] { initialMessage, warningMessage });
string[] warningMessages = GetMessagesForLevel(ConfigStatus.ErrorLevel.Warning,
new[] { initialLevel, ConfigStatus.ErrorLevel.Warning },
new[] { initialMessage, warningMessage });
Assert.That(status.AllMessages,
Is.EquivalentTo(errorMessages.Concat(warningMessages)));
Assert.That(status.ErrorMessages, Is.EquivalentTo(errorMessages));
Assert.That(status.MessagesByErrorLevel(ConfigStatus.ErrorLevel.Error),
Is.EquivalentTo(errorMessages));
Assert.That(status.WarningMessages, Is.EquivalentTo(warningMessages));
Assert.That(status.MessagesByErrorLevel(ConfigStatus.ErrorLevel.Warning),
Is.EquivalentTo(warningMessages));
Assert.That(status.MessagesByErrorLevel(ConfigStatus.ErrorLevel.Ok), Is.Null);
}
public void AppendErrorTest(ConfigStatus.ErrorLevel initialLevel)
{
var newLevel = ConfigStatus.ErrorLevel.Error;
string initialMessage = "Message init";
string errorMessage = "Error message";
ConfigStatus status = StatusBySeverityLevel(initialLevel, initialMessage);
status.AppendError(errorMessage);
Assert.That(status.SeverityLevel, Is.EqualTo(newLevel));
Assert.That(status.IsOk, Is.EqualTo(false));
Assert.That(status.IsWarningLevel, Is.EqualTo(false));
Assert.That(status.IsErrorLevel, Is.EqualTo(true));
string[] errorMessages = GetMessagesForLevel(ConfigStatus.ErrorLevel.Error,
new[] { initialLevel, ConfigStatus.ErrorLevel.Error },
new[] { initialMessage, errorMessage });
string[] warningMessages = GetMessagesForLevel(ConfigStatus.ErrorLevel.Warning,
new[] { initialLevel, ConfigStatus.ErrorLevel.Error },
new[] { initialMessage, errorMessage });
Assert.That(status.AllMessages,
Is.EquivalentTo(errorMessages.Concat(warningMessages)));
Assert.That(status.ErrorMessages, Is.EquivalentTo(errorMessages));
Assert.That(status.MessagesByErrorLevel(ConfigStatus.ErrorLevel.Error),
Is.EquivalentTo(errorMessages));
Assert.That(status.WarningMessages, Is.EquivalentTo(warningMessages));
Assert.That(status.MessagesByErrorLevel(ConfigStatus.ErrorLevel.Warning),
Is.EquivalentTo(warningMessages));
Assert.That(status.MessagesByErrorLevel(ConfigStatus.ErrorLevel.Ok), Is.Null);
}
public void GetFinalQueryStringWithWarning()
{
Dictionary <string, string> queryParameters = AllValidQueryParams;
ConfigStatus status =
_target.GetFinalQueryString(queryParameters, out string queryString);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(1));
Assert.That(status.AllMessages.Count, Is.EqualTo(1));
Assert.That(
status.WarningMessage.Contains("The following query parameters will be ignored"));
foreach (KeyValuePair <string, string> ignoreQueryParam in IgnoreQueryParams)
{
Assert.That(
status.WarningMessage.Contains($"'{ignoreQueryParam.Key}'"));
}
NameValueCollection parsedQuery = HttpUtility.ParseQueryString(queryString);
Dictionary <string, string> queryDict =
parsedQuery.AllKeys.ToDictionary(k => k, k => parsedQuery.Get(k));
Assert.That(queryDict, Is.EqualTo(OtherQueryParams));
}
/// <summary>
/// Invokes the <see cref="OnConfigurationFailed"/> event.
/// </summary>
/// <param name="sensor"></param>
/// <param name="gesture"></param>
internal void OnConfigurationFailed(ConfigStatus sensor, ConfigStatus gesture)
{
if (ConfigurationFailed != null)
{
ConfigurationFailed.Invoke(sensor, gesture);
}
}
public void Setup()
{
_sdkConfigFactory = Substitute.For <ISdkConfigFactory>();
_sdkConfigFactory.LoadGgpSdkConfigOrDefault().Returns(_sdkConfig);
_queryParametersParser = Substitute.For <IQueryParametersParser>();
IDictionary <string, string> dict = new Dictionary <string, string>();
_queryParametersParser
.GetFinalQueryString(dict, out string _)
.Returns(x =>
{
x[1] = string.Empty;
return(ConfigStatus.OkStatus());
});
_queryParametersParser
.ParametersToDictionary(Arg.Any <string>(), out IDictionary <string, string> _)
.Returns(x =>
{
x[1] = dict;
return(ConfigStatus.OkStatus());
});
_queryParametersParser.ParseToLaunchRequest(dict, Arg.Any <LaunchGameRequest>())
.Returns(ConfigStatus.OkStatus());
_queryParametersParser
.ParseToParameters(dict, Arg.Any <LaunchParams>())
.Returns(ConfigStatus.OkStatus());
_target = new LaunchGameParamsConverter(_sdkConfigFactory, _queryParametersParser);
}
private void Initialize()
{
ConfigStatus status = ValidatePrerequisite();
if (status != ConfigStatus.AllGood && status != ConfigStatus.NoIdentityClaimType)
{
this.LabelErrorMessage.Text = base.MostImportantError;
this.HideAllContent = true;
this.BtnCreateNewItem.Visible = false;
return;
}
TrustName = CurrentTrustedLoginProvider.Name;
if (!this.IsPostBack)
{
// NEW ITEM FORM
// Populate picker entity metadata DDL
DdlNewEntityMetadata.Items.Add(String.Empty);
Type EntityDataKeysInfo = typeof(PeopleEditorEntityDataKeys);
foreach (object field in EntityDataKeysInfo.GetFields())
{
DdlNewEntityMetadata.Items.Add(((FieldInfo)field).Name);
}
// Populate EntityType DDL
foreach (var value in Enum.GetValues(typeof(DirectoryObjectType)))
{
DdlNewDirectoryObjectType.Items.Add(value.ToString());
}
}
BuildAttributesListTable(this.IsPostBack);
}
public void ToLaunchGameRequestEnvironmentVariablesInvalid()
{
LaunchParams parameters = ValidParams;
parameters.GameletEnvironmentVars = " =asd ;=;v=a ;v=;2V==;v= ==bb ; ; ";
parameters.Rgp = false;
parameters.RenderDoc = false;
parameters.VulkanDriverVariant = string.Empty;
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(4));
Assert.That(status.AllMessages.Count, Is.EqualTo(4));
Assert.That(
status.WarningMessages.Count(
m => m.Contains("Invalid format of environment variable")), Is.EqualTo(2));
Assert.That(status.WarningMessages.Count(m => m.Contains("is set multiple times.")),
Is.EqualTo(1));
Assert.That(status.WarningMessages.Count(m => m.Contains("edit the setting")),
Is.EqualTo(1));
Assert.That(request.EnvironmentVariablePairs, Is.EqualTo(new Dictionary <string, string>
{
{ "v", " ==bb" },
{ "2V", "=" }
}));
}
public void ToLaunchGameRequestEnvironmentVariablesOverride()
{
LaunchParams parameters = ValidParams;
parameters.RenderDoc = false;
parameters.VulkanDriverVariant = "test_variant";
parameters.Rgp = true;
parameters.GameletEnvironmentVars =
"GGP_DEV_VK_DRIVER_VARIANT=otherVariant;RGP_DEBUG_LOG_FILE=my/path.log";
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(3));
Assert.That(status.AllMessages.Count, Is.EqualTo(3));
Assert.That(status.WarningMessages[0].Contains("overrides the setting variable"));
Assert.That(status.WarningMessages[1].Contains("overrides the setting variable"));
Assert.That(status.WarningMessages[2].Contains("edit the setting"));
Assert.IsNotNull(request);
Assert.That(request.EnvironmentVariablePairs, Is.EqualTo(new Dictionary <string, string>
{
{ "GGP_DEV_VK_DRIVER_VARIANT", "otherVariant" },
{ "GGP_INTERNAL_LOAD_RGP", "1" },
{ "RGP_DEBUG_LOG_FILE", "my/path.log" },
{ "LD_PRELOAD", "librgpserver.so" },
}));
}
public async Task <(bool success, string failureMessage)> LoginAsync(string account, string password)
{
var client = new RestClient(CloudUtils.Api.GetCliUrl(RestUrlLogin))
{
Timeout = -1
};
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", TranslateUtils.JsonSerialize(new LoginRequest
{
Account = account,
Password = AuthUtils.Md5ByString(password),
IsPersistent = true
}), ParameterType.RequestBody);
var response = client.Execute <LoginResult>(request);
if (!response.IsSuccessful)
{
return(false, "your account or password was incorrect");
}
var loginResult = response.Data;
var status = new ConfigStatus
{
UserName = loginResult.UserName,
AccessToken = loginResult.AccessToken
};
await _configService.SaveStatusAsync(status);
return(true, null);
}
/// <summary>
/// Ensures configuration is valid to proceed
/// </summary>
/// <returns></returns>
public virtual ConfigStatus ValidatePrerequisite()
{
Status = ConfigStatus.AllGood;
if (PersistedObject == null)
{
Status |= ConfigStatus.PersistedObjectNotFound;
}
if (CurrentTrustedLoginProvider == null)
{
CurrentTrustedLoginProvider = LDAPCP.GetSPTrustAssociatedWithCP(LDAPCP._ProviderInternalName);
if (CurrentTrustedLoginProvider == null)
{
Status |= ConfigStatus.NoSPTrustAssociation;
}
}
if (IdentityClaim == null && Status == ConfigStatus.AllGood)
{
IdentityClaim = this.IdentityClaim = PersistedObject.AttributesListProp.Find(x => String.Equals(CurrentTrustedLoginProvider.IdentityClaimTypeInformation.MappedClaimType, x.ClaimType, StringComparison.InvariantCultureIgnoreCase) && !x.CreateAsIdentityClaim);
if (IdentityClaim == null)
{
Status |= ConfigStatus.NoIdentityClaimType;
}
}
if (PersistedObjectVersion != PersistedObject.Version)
{
Status |= ConfigStatus.PersistedObjectStale;
}
if (Status != ConfigStatus.AllGood)
{
LdapcpLogging.Log(String.Format(MostImportantError), TraceSeverity.High, EventSeverity.Information, LdapcpLogging.Categories.Configuration);
}
return(Status);
}
public async Task <(bool success, string failureMessage)> LoginAsync(string account, string password)
{
var url = GetCliUrl(RestUrlLogin);
var(success, result, _) = await RestUtils.PostAsync <LoginRequest, LoginResult>(url,
new LoginRequest
{
Account = account,
Password = AuthUtils.Md5ByString(password),
IsPersistent = true
});
if (!success)
{
return(false, "your account or password was incorrect");
}
var status = new ConfigStatus
{
UserName = result.UserName,
AccessToken = result.AccessToken
};
await _configService.SaveStatusAsync(status);
return(true, null);
}
void ParseValueFailure(string paramName, bool launchRequest,
Dictionary <string, Tuple <string, ConfigStatus.ErrorLevel> >
invalidValues)
{
foreach (KeyValuePair <string, Tuple <string, ConfigStatus.ErrorLevel> > valuePair in
invalidValues)
{
string paramValue = valuePair.Key;
string messagePart = valuePair.Value.Item1;
ConfigStatus.ErrorLevel expectedErrorLevel = valuePair.Value.Item2;
var queryParams = new Dictionary <string, string>
{
{ paramName, paramValue }
};
LaunchGameRequest request = ShallowCopy(ValidRequest);
LaunchParams parameters = ShallowCopy(ValidParams);
ConfigStatus status = launchRequest
? _target.ParseToLaunchRequest(queryParams, request)
: _target.ParseToParameters(queryParams, parameters);
// Verify that corresponding message is populated.
Assert.That(status.SeverityLevel, Is.EqualTo(expectedErrorLevel));
Assert.That(status.MessagesByErrorLevel(expectedErrorLevel).Count, Is.EqualTo(1));
Assert.That(status.AllMessages.Count, Is.EqualTo(1));
Assert.That(status.AllMessages[0].Contains(messagePart));
object obj = launchRequest ? (object)request : parameters;
Type type = launchRequest
? typeof(LaunchGameRequest)
: typeof(LaunchParams);
object originObject = launchRequest ? (object)ValidRequest : ValidParams;
// Assert that all properties are unchanged.
AssertObjectPropertiesEqual(type, obj, originObject);
}
}
/// <summary>
/// Merge the custom query string into the given set of parameters. If there is a parameter
/// collision, the custom parameter will be selected.
/// </summary>
ConfigStatus TryMergeCustomQueryString(IEnumerable <QueryParam> queryParams,
out IEnumerable <QueryParam> outParams)
{
var paramsByName = queryParams.Where(p => p != null).ToDictionary(p => p.Name);
ConfigStatus status = TryParseQueryString(
LaunchParams.QueryParams, out IEnumerable <QueryParam> customQueryParams);
if (status.IsOk)
{
foreach (QueryParam customParam in customQueryParams)
{
if (paramsByName.ContainsKey(customParam.Name))
{
Trace.WriteLine("Warning: Custom query parameter is replacing previous " +
$"value. Param: {customParam.Name}, " +
$"Previous value: {paramsByName[customParam.Name]}, " +
$"New Value: {customParam.Value}");
paramsByName[customParam.Name] = customParam;
}
else
{
paramsByName.Add(customParam.Name, customParam);
}
}
}
outParams = paramsByName.Values;
return(status);
}
void CheckInvalidEnvVars(string paramName, string[] invalidEnvVarsValues,
string[] messageParts)
{
foreach (string paramVal in invalidEnvVarsValues)
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
var queryParams = new Dictionary <string, string>
{
{ paramName, paramVal }
};
launchRequest.EnvironmentVariablePairs = new Dictionary <string, string>();
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(1));
Assert.That(status.AllMessages.Count, Is.EqualTo(1));
foreach (string messagePart in messageParts)
{
Assert.That(
status.AllMessages[0].Contains(string.Format(messagePart, paramVal)));
}
Assert.That(!launchRequest.EnvironmentVariablePairs.Any());
}
}
public void CreateLaunchSdkWarningSetting(ShowOption sdkShowOption, string[] versionsToHide,
bool showSdkWarning)
{
SetupSdkCompatibility(GameletSdkCompatibilityResult.NotCompatibleOutsideOfRange);
var launchRequest = new LaunchGameRequest();
SetupParamsParser(launchRequest, ConfigStatus.OkStatus());
var launchGameResponse = new LaunchGameResponse
{
GameLaunchName = _gameLaunchName, RequestId = launchRequest.RequestId
};
SetupGameLaunchApi(launchRequest, launchGameResponse);
_yetiVsiService.Options.SdkCompatibilityWarningOption.Returns(sdkShowOption);
_yetiVsiService.Options
.SdkVersionsAreHidden(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>())
.Returns(false);
foreach (string versions in versionsToHide)
{
string gameletVersion = versions.Split('/')[0];
string localVersion = versions.Split('/')[1];
_yetiVsiService.Options
.SdkVersionsAreHidden(gameletVersion, localVersion, _gameletName).Returns(true);
}
IVsiGameLaunch result = _target.CreateLaunch(_launchParams);
Assert.That(result, Is.Not.Null);
_dialogUtil.DidNotReceiveWithAnyArgs().ShowError(default);
void CheckValidEnvVars(string paramName, string envVarName,
Dictionary <string, string> validEnvVarsValues)
{
foreach (KeyValuePair <string, string> validEnvVarsValue in validEnvVarsValues)
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
var queryParams = new Dictionary <string, string>
{
{ paramName, validEnvVarsValue.Key }
};
launchRequest.EnvironmentVariablePairs = new Dictionary <string, string>();
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsOk, Is.EqualTo(true));
if (validEnvVarsValue.Value == null)
{
Assert.That(!launchRequest.EnvironmentVariablePairs.Any());
}
else
{
Assert.That(launchRequest.EnvironmentVariablePairs, Is.EqualTo(
new Dictionary <string, string>
{
{ envVarName, validEnvVarsValue.Value }
}));
}
}
}
public void ParseToParametersAllQueryParameters()
{
LaunchParams parameters = ShallowCopy(ValidParams);
Dictionary <string, string> queryParams = AllValidQueryParams;
int expectedOutQueryParametersCount = queryParams.Count;
ConfigStatus status = _target.ParseToParameters(queryParams, parameters);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(queryParams.Count, Is.EqualTo(expectedOutQueryParametersCount));
Assert.That(parameters.Account, Is.EqualTo("some_account"));
Assert.That(parameters.ApplicationName, Is.EqualTo("test/app"));
Assert.That(parameters.Cmd, Is.EqualTo(" some_bin arg2"));
Assert.That(parameters.Debug, Is.EqualTo(true));
Assert.That(parameters.GameletEnvironmentVars,
Is.EqualTo("Var1=1;vAR2=3;ParamsVar=val"));
Assert.That(parameters.GameletName, Is.EqualTo("test/gamelet"));
Assert.That(parameters.PoolId, Is.EqualTo("test_pool"));
Assert.That(parameters.RenderDoc, Is.EqualTo(false));
Assert.That(parameters.Rgp, Is.EqualTo(true));
Assert.That(parameters.SdkVersion, Is.EqualTo("1"));
Assert.That(parameters.VulkanDriverVariant, Is.EqualTo("test_variant"));
Assert.That(parameters.SurfaceEnforcementMode,
Is.EqualTo(SurfaceEnforcementSetting.Warn));
Assert.That(parameters.TestAccount,
Is.EqualTo("organizations/organization_id/" +
"projects/project_id/testAccounts/gamer#1234"));
Assert.That(parameters.QueryParams, Is.EqualTo(""));
}
private void PollForDeviceConfigCompletion()
{
#if UNITY_EDITOR
unsafe
{
ConfigStatus sensorConfigStatus = ConfigStatus.Idle;
ConfigStatus gestureConfigStatus = ConfigStatus.Idle;
// WearableUSBGetConfigStatus returns true if the bridge has just received responses from the
// device for an attempt to set the device configuration. So this check will pass once for
// every call to WearableUSBSetDeviceConfiguration, some number of frames later.
if (WearableUSBGetConfigStatus(&sensorConfigStatus, &gestureConfigStatus))
{
if (sensorConfigStatus == ConfigStatus.Failure || gestureConfigStatus == ConfigStatus.Failure)
{
OnConfigurationFailed(sensorConfigStatus, gestureConfigStatus);
}
else
{
OnConfigurationSucceeded();
}
}
}
#endif // UNITY_EDITOR
}
public async Task ExecuteAsync(IPluginJobContext context)
{
if (!CliUtils.ParseArgs(_options, context.Args))
{
return;
}
if (_isHelp)
{
PrintUsage();
return;
}
var status = _configService.Status;
if (status == null || string.IsNullOrEmpty(status.UserName) || string.IsNullOrEmpty(status.AccessToken))
{
await WriteUtils.PrintErrorAsync("you have not logged in");
return;
}
status = new ConfigStatus
{
UserName = string.Empty,
AccessToken = string.Empty
};
await _configService.SaveStatusAsync(status);
await WriteUtils.PrintSuccessAsync("you have successful logged out");
}
internal static void SetConfig(string Key, string Name, string Value, string CfgFile)
{
VerifyHeader(CfgFile);
ConfigStatus cfg = GetConfigStatus(Key, Name, CfgFile);
if (cfg == ConfigStatus.NoFile)
{
File.WriteAllText(CfgFile, "[" + Key + "]");
cfg = ConfigStatus.NoName;
}
string[] Lines = File.ReadAllLines(CfgFile, Encoding.UTF8);
string AtualKey = string.Empty;
if (cfg == ConfigStatus.Ok)
{
for (int i = 0; i < Lines.Length; i++)
{
string Line = Lines[i];
if (Line.StartsWith("[") && Line.EndsWith("]"))
{
AtualKey = Line.Substring(1, Line.Length - 2);
}
if (Line.StartsWith("!") || string.IsNullOrWhiteSpace(Line) || !Line.Contains("=") || Line.StartsWith("#") || Line.StartsWith(";"))
{
continue;
}
string AtualName = Line.Split('=')[0].Trim();
if (Name.Split(';').Any(N => N.Trim() == AtualName.Trim()) && AtualKey == Key)
{
Lines[i] = string.Format("{0}={1}", Name, Value);
break;
}
}
}
if (cfg == ConfigStatus.NoName)
{
List <string> Cfgs = new List <string>();
int KeyPos = 0;
for (int i = 0; i < Lines.Length; i++)
{
if (string.Format("[{0}]", Key) == Lines[i])
{
KeyPos = i;
}
Cfgs.Add(Lines[i]);
}
Cfgs.Insert(KeyPos + 1, string.Format("{0}={1}", Name, Value));
Lines = Cfgs.ToArray();
}
if (cfg == ConfigStatus.NoKey)
{
string[] NewLines = new string[Lines.Length + 3];
Lines.CopyTo(NewLines, 0);
NewLines[Lines.Length + 1] = string.Format("[{0}]", Key);
NewLines[Lines.Length + 2] = string.Format("{0}={1}", Name, Value);
Lines = NewLines;
}
File.WriteAllLines(CfgFile, Lines, Encoding.UTF8);
}
public void ToLaunchGameRequestValidParams()
{
LaunchParams parameters = ValidParams;
parameters.GameletEnvironmentVars =
" Var1=test_V=a==l; vaR2=47 ; var3 = ; var1 =";
parameters.RenderDoc = false;
parameters.Rgp = false;
parameters.VulkanDriverVariant = string.Empty;
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.Parent, Is.EqualTo(parameters.TestAccount));
Assert.That(request.GameletName, Is.EqualTo(parameters.GameletName));
Assert.That(request.ApplicationName, Is.EqualTo(parameters.ApplicationName));
Assert.That(request.ExecutablePath, Is.EqualTo("some_bin"));
Assert.That(request.CommandLineArguments, Is.EqualTo(new [] { "arg1" }));
Assert.That(request.EnvironmentVariablePairs, Is.EqualTo(new Dictionary <string, string>
{
{ "Var1", "test_V=a==l" },
{ "vaR2", "47" },
{ "var3 ", string.Empty },
{ "var1 ", string.Empty }
}));
Assert.That(request.SurfaceEnforcementMode,
Is.EqualTo(parameters.SurfaceEnforcementMode));
Assert.That(request.Debug, Is.EqualTo(parameters.Debug));
// Assert another parameters values are default.
Assert.That(request.EnablePipelineCacheSourceUpload, Is.EqualTo(null));
Assert.That(request.EnableRetroactiveFrameDump, Is.EqualTo(null));
Assert.That(request.StreamQualityPreset, Is.EqualTo(StreamQualityPreset.Undefined));
Assert.That(request.AddInstanceCompatibilityRequirements.Length, Is.EqualTo(0));
Assert.That(request.RemoveInstanceCompatibilityRequirements.Length, Is.EqualTo(0));
Assert.That(request.DeepLinkParamsIdGameData, Is.EqualTo(null));
Assert.That(request.EnableGameRealtimePriority, Is.EqualTo(null));
Assert.That(request.EnforceProductionRam, Is.EqualTo(null));
Assert.That(request.GameStateName, Is.EqualTo(null));
Assert.That(request.ReleaseName, Is.EqualTo(null));
Assert.That(request.MountDynamicContent, Is.EqualTo(null));
Assert.That(request.MountUploadedPipelineCache, Is.EqualTo(null));
Assert.That(request.OverrideAudioChannelMode, Is.EqualTo(ChannelMode.Unspecified));
Assert.That(request.OverrideClientResolution, Is.EqualTo(VideoResolution.Unspecified));
Assert.That(request.OverrideDisplayPixelDensity, Is.EqualTo(null));
Assert.That(request.OverrideDynamicRange, Is.EqualTo(DynamicRange.Unspecified));
Assert.That(request.OverridePreferredCodec, Is.EqualTo(Codec.Unspecified));
Assert.That(request.PackageName, Is.EqualTo(null));
Assert.That(request.StartForwardFrameDump, Is.EqualTo(null));
Assert.That(request.StreamerFixedFps, Is.EqualTo(null));
Assert.That(request.StreamerFixedResolution, Is.EqualTo(VideoResolution.Unspecified));
Assert.That(request.StreamerMaximumBandWidthKbps, Is.EqualTo(null));
Assert.That(request.StreamerMinimumBandWidthKbps, Is.EqualTo(null));
Assert.That(request.EnableDeveloperResumeOffer, Is.EqualTo(false));
}
internal static void SetConfig(string Key, string Name, string Value)
{
#if !DEBUG
string cfgfile = AppDomain.CurrentDomain.BaseDirectory + "Settings.ini";
ConfigStatus cfg = GetConfigStatus(Key, Name);
string[] Lines = File.ReadAllLines(cfgfile, Encoding.UTF8);
string AtualKey = string.Empty;
if (cfg == ConfigStatus.Ok)
{
for (int i = 0; i < Lines.Length; i++)
{
string Line = Lines[i];
if (Line.StartsWith("[") && Line.EndsWith("]"))
{
AtualKey = Line.Substring(1, Line.Length - 2);
}
if (Line.StartsWith("!") || string.IsNullOrWhiteSpace(Line) || !Line.Contains("="))
{
continue;
}
string AtualName = Line.Split('=')[0];
if (AtualKey == Key && Name == AtualName)
{
Lines[i] = string.Format("{0}={1}", Name, Value);
break;
}
}
}
if (cfg == ConfigStatus.NoName)
{
List <string> Cfgs = new List <string>();
int KeyPos = 0;
for (int i = 0; i < Lines.Length; i++)
{
if (string.Format("[{0}]", Key) == Lines[i])
{
KeyPos = i;
}
Cfgs.Add(Lines[i]);
}
Cfgs.Insert(KeyPos + 1, string.Format("{0}={1}", Name, Value));
Lines = Cfgs.ToArray();
}
if (cfg == ConfigStatus.NoKey)
{
string[] NewLines = new string[Lines.Length + 3];
Lines.CopyTo(NewLines, 0);
NewLines[Lines.Length + 1] = string.Format("[{0}]", Key);
NewLines[Lines.Length + 2] = string.Format("{0}={1}", Name, Value);
Lines = NewLines;
}
File.WriteAllLines(cfgfile, Lines, Encoding.UTF8);
#endif
}
public async Task SaveStatusAsync(ConfigStatus status)
{
var configPath = CliUtils.GetOsUserConfigFilePath();
var config = new Config
{
Status = status
};
await FileUtils.WriteTextAsync(configPath, TranslateUtils.JsonSerialize(config));
}
public void ParametersToDictionaryFailure(string input)
{
ConfigStatus status =
_target.ParametersToDictionary(input, out IDictionary <string, string> result);
Assert.That(status.IsWarningLevel, Is.EqualTo(true));
Assert.That(status.WarningMessages.Count, Is.EqualTo(1));
Assert.That(
status.WarningMessage.Contains(
"The 'Custom Query Parameters' value is in a wrong format"));
Assert.That(result, Is.Empty);
}
public void ParametersToDictionarySuccess(string input, string[] output)
{
ConfigStatus status =
_target.ParametersToDictionary(input, out IDictionary <string, string> result);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(result.Count, Is.EqualTo(output.Length / 2));
for (int i = 0; i < output.Length / 2; ++i)
{
Assert.That(result[output[i * 2]], Is.EqualTo(output[i * 2 + 1]));
}
}
public void ParseToRequestAllQueryParameters()
{
LaunchGameRequest launchRequest = ShallowCopy(ValidRequest);
Dictionary <string, string> queryParams = AllValidQueryParams;
int expectedOutQueryParametersCount = queryParams.Count;
ConfigStatus status = _target.ParseToLaunchRequest(queryParams, launchRequest);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(queryParams.Count, Is.EqualTo(expectedOutQueryParametersCount));
Assert.That(launchRequest.Parent, Is.EqualTo("Request_parent"));
Assert.That(launchRequest.GameletName, Is.EqualTo("Request_gamelet_name"));
Assert.That(launchRequest.ApplicationName, Is.EqualTo("params_app_name"));
Assert.That(launchRequest.ReleaseName, Is.EqualTo(null));
Assert.That(launchRequest.EnablePipelineCacheSourceUpload, Is.EqualTo(false));
Assert.That(launchRequest.EnableGameRealtimePriority, Is.EqualTo(true));
Assert.That(launchRequest.EnforceProductionRam, Is.EqualTo(false));
Assert.That(launchRequest.ExecutablePath, Is.EqualTo("Request_bin"));
Assert.That(launchRequest.CommandLineArguments,
Is.EqualTo(new[] { "Request_arg1", "--arg456" }));
Assert.That(launchRequest.EnvironmentVariablePairs,
Is.EqualTo(new Dictionary <string, string>
{
{ "Request_VAR1", "Some value" }
}));
Assert.That(launchRequest.SurfaceEnforcementMode,
Is.EqualTo(SurfaceEnforcementSetting.Warn));
Assert.That(launchRequest.Debug, Is.EqualTo(true));
Assert.That(launchRequest.MountUploadedPipelineCache, Is.EqualTo(true));
Assert.That(launchRequest.MountDynamicContent, Is.EqualTo(true));
Assert.That(launchRequest.GameStateName, Is.EqualTo("params_game_state_name"));
Assert.That(launchRequest.DeepLinkParamsIdGameData, Is.EqualTo(23475456543));
Assert.That(launchRequest.PackageName, Is.EqualTo("params_package_name"));
Assert.That(launchRequest.StreamerMinimumBandWidthKbps, Is.EqualTo(23));
Assert.That(launchRequest.StreamerMaximumBandWidthKbps, Is.EqualTo(8764));
Assert.That(launchRequest.StreamerFixedFps, Is.EqualTo(765));
Assert.That(launchRequest.OverrideClientResolution, Is.EqualTo(VideoResolution._720P));
Assert.That(launchRequest.OverrideDynamicRange, Is.EqualTo(DynamicRange.Sdr));
Assert.That(launchRequest.OverrideAudioChannelMode,
Is.EqualTo(ChannelMode.Surround51True));
Assert.That(launchRequest.StreamerFixedResolution, Is.EqualTo(VideoResolution._1440P));
Assert.That(launchRequest.OverrideDisplayPixelDensity, Is.EqualTo(9876));
Assert.That(launchRequest.StartForwardFrameDump, Is.EqualTo(false));
Assert.That(launchRequest.AddInstanceCompatibilityRequirements,
Is.EqualTo(new[] { "r1", "other" }));
Assert.That(launchRequest.RemoveInstanceCompatibilityRequirements,
Is.EqualTo(new[] { "5", "7", " 8" }));
Assert.That(launchRequest.OverridePreferredCodec, Is.EqualTo(Codec.Vp9));
Assert.That(launchRequest.EnableRetroactiveFrameDump, Is.EqualTo(true));
Assert.That(launchRequest.StreamQualityPreset,
Is.EqualTo(StreamQualityPreset.HighVisualQuality));
Assert.That(launchRequest.NetworkModel, Is.EqualTo("test - model"));
}
public void ParseParamsCmdSuccess(string cmdValue)
{
LaunchParams parameters = ShallowCopy(ValidParams);
var queryParams = new Dictionary <string, string>
{
{ "cmd", cmdValue }
};
ConfigStatus status = _target.ParseToParameters(queryParams, parameters);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.That(parameters.Cmd, Is.EqualTo(cmdValue));
}
public void ToLaunchGameRequestParentNoTestAccount()
{
LaunchParams parameters = ValidParams;
parameters.TestAccount = " ";
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.Parent, Is.EqualTo("organizations/-/players/me"));
}
public void ToLaunchGameRequestCommandArgumentsValid(string cmd, string[] expectedOutput)
{
LaunchParams parameters = ValidParams;
parameters.Cmd = cmd;
ConfigStatus status =
_target.ToLaunchGameRequest(parameters, out LaunchGameRequest request);
Assert.That(status.IsOk, Is.EqualTo(true));
Assert.IsNotNull(request);
Assert.That(request.CommandLineArguments, Is.EqualTo(expectedOutput));
}
void AssertStatusesEqual(ConfigStatus actual, ConfigStatus expected)
{
Type t = typeof(ConfigStatus);
IEnumerable <PropertyInfo> properties =
t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo prop in properties)
{
object actualVal = prop.GetValue(actual);
object expectedVal = prop.GetValue(expected);
Assert.That(actualVal, Is.EqualTo(expectedVal));
}
}
