Fishing-Travel/ft
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
144e7f739f4893ce88e82f3464e39dd511cb4dbe
ft/Client/Assets/Scripts/Services/PlayerData/PlayerKVEditorValidationHost.cs

4912 lines
262 KiB
C#
Raw Blame History

#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using Newtonsoft.Json;
using UnityEditor;
using UniRx;
namespace game.PlayerDataStorage
{
// Fixed validation entry; business coverage uses original methods, resource tests remain in their own hosts.
internal static class PlayerKVEditorValidationHost
{
private static T UserField<T>(KVUserService user, string name)
{
return (T)typeof(KVUserService).GetField(name, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(user);
}
private static void SetUserField(KVUserService user, string name, object value)
{
typeof(KVUserService).GetField(name, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).SetValue(user, value);
}
internal static Task<string> RunAsync(string caseId)
{
if (failedFormalMatchCleanup != null)
{
throw new InvalidOperationException("Previous formal matching cleanup is incomplete.");
}
if (caseId == "P15-FormalMatchState")
{
return RunFormalMatchmaking(true);
}
if (caseId == "P15-FormalMatchmaking")
{
return RunFormalMatchmaking();
}
if (caseId == "P12C-StartupSubscriptions")
{
return RunFriends(true);
}
if (caseId == "P14-FormalRealtime")
{
return RunFormalReadAdapters(true);
}
if (caseId == "P12B-FormalReadAdapters")
{
return RunFormalReadAdapters();
}
if (caseId == "P12A-OrdinaryCadence")
{
return RunOrdinarySave(false, true);
}
if (caseId == "P8D-Matchmaking")
{
return RunMatchmaking();
}
if (caseId == "P8C-TitleNews-Cleanup")
{
return RunTitleNews(true);
}
if (caseId == "P8C-TitleNews")
{
return RunTitleNews();
}
if (caseId == "P8B-Friends")
{
return RunFriends();
}
if (caseId == "P8A-Leaderboard")
{
return RunLeaderboard();
}
if (caseId == "P6B-OrdinarySave-Cleanup")
{
return RunOrdinarySave(true);
}
if (caseId == "P6B-OrdinarySave")
{
return RunOrdinarySave();
}
if (caseId == "P6A-InitializationLastLogin")
{
return RunInitializationLastLogin();
}
if (caseId == "M03B-LoginRetry")
{
return RunLoginRetry();
}
if (caseId == "M03B-LoginRetry-Cleanup")
{
return CleanupLoginRetry();
}
if (caseId == "M03C-CustomId")
{
return RunCustomId();
}
if (caseId == "M03D-Destroy")
{
return RunDestroyBoundary();
}
if (caseId == "M01-Immediate")
{
return RunImmediateConsumers();
}
return Module02OriginalLoadTests.RunAsync(caseId);
}
private sealed class LeaderboardContext : System.Threading.SynchronizationContext
{
internal readonly List<Exception> Errors = new List<Exception>();
private readonly System.Threading.SynchronizationContext original;
private TaskCompletionSource<bool> idle = new TaskCompletionSource<bool>();
internal int Active
{
get;
private set;
}
internal int Started
{
get;
private set;
}
internal int Posted
{
get;
private set;
}
internal LeaderboardContext(System.Threading.SynchronizationContext original)
{
this.original = original ?? throw new InvalidOperationException("Editor context required.");
idle.SetResult(true);
}
public override void OperationStarted()
{
Started++;
if (Active++ == 0)
{
idle = new TaskCompletionSource<bool>();
}
}
public override void OperationCompleted()
{
if (--Active == 0)
{
idle.TrySetResult(true);
}
}
public override void Post(System.Threading.SendOrPostCallback callback, object state)
{
Posted++;
original.Post(_ =>
{
var previous = Current;
SetSynchronizationContext(this);
try
{
callback(state);
}
catch (Exception ex)
{
Errors.Add(ex);
}
finally
{
SetSynchronizationContext(previous);
}
}, null);
}
internal Task WaitForIdle()
{
return idle.Task;
}
}
private static object failedFormalReadCleanup;
private sealed class FormalReadHttp : System.Net.Http.DelegatingHandler
{
internal static readonly string[] Routes = { "account/Login", "playerdata/Get", "leaderboard/GetLeaderboard", "friend/GetFriendsList", "commondata/GetTitleNews", "friend/SearchFriend" };
internal static readonly string[] Bodies = { "{\"playerId\":\"101\"}", "{}", "{\"statisticName\":\"LevelB\",\"startPosition\":0,\"maxResultsCount\":2}", "{}", "{}", "{\"PlayFabId\":\"102\"}" };
private readonly object gate;
private readonly List<string> admitted;
private readonly List<int> statuses;
private readonly Dictionary<string, string> responses;
private readonly HashSet<string> failures;
private readonly System.Threading.CancellationToken lifetime;
internal FormalReadHttp(System.Net.Http.HttpMessageHandler inner, object gate, List<string> admitted,
List<int> statuses, Dictionary<string, string> responses, HashSet<string> failures,
System.Threading.CancellationToken lifetime) : base(inner)
{
this.gate = gate;
this.admitted = admitted;
this.statuses = statuses;
this.responses = responses;
this.failures = failures;
this.lifetime = lifetime;
}
protected override async Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken token)
{
try
{
var body = Newtonsoft.Json.Linq.JToken.Parse(await request.Content.ReadAsStringAsync());
int index;
lock (gate)
{
index = admitted.Count;
if (failures.Count != 0 || index >= Routes.Length || statuses.Count != index ||
request.Method != System.Net.Http.HttpMethod.Post ||
request.RequestUri.AbsoluteUri != PlayerKVRuntimeSelection.FormalApiUrl + Routes[index] ||
!(body is Newtonsoft.Json.Linq.JObject) ||
!Newtonsoft.Json.Linq.JToken.DeepEquals(body, Newtonsoft.Json.Linq.JToken.Parse(Bodies[index])))
{
throw new InvalidOperationException("Formal read request rejected.");
}
admitted.Add(Routes[index]);
}
using (var linked = System.Threading.CancellationTokenSource.CreateLinkedTokenSource(token, lifetime))
{
var response = await base.SendAsync(request, linked.Token).ConfigureAwait(false);
try
{
var text = index >= 2 ? await response.Content.ReadAsStringAsync().ConfigureAwait(false) : null;
lock (gate)
{
statuses.Add((int)response.StatusCode);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
failures.Add("HTTP" + (int)response.StatusCode);
}
if (text != null)
{
responses[Routes[index]] = text;
}
}
return response;
}
catch
{
response.Dispose();
throw;
}
}
}
catch (Exception ex)
{
lock (gate)
{
failures.Add(ex.GetType().Name);
}
throw;
}
}
}
private static async Task<string> RunFormalReadAdapters(bool verifyRealtime = false)
{
var instanceField = typeof(KVMgr).GetField("instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
void RequireIdle()
{
if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating ||
asap.core.GContext.Ready || PlayerKVGameplayLoop.Enabled || instanceField.GetValue(null) != null ||
UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 ||
PlayerKVShutdownRegistry.Process.Status != PlayerKVShutdownStatus.Ready)
{
throw new InvalidOperationException("Formal read validation requires an idle Editor.");
}
}
RequireIdle();
if (running || failedFormalReadCleanup != null)
{
throw new InvalidOperationException("Previous validation has not closed.");
}
running = true;
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var originalContext = System.Threading.SynchronizationContext.Current;
var gate = new object();
var admitted = new List<string>();
var statuses = new List<int>();
var responses = new Dictionary<string, string>();
var transportFailures = new HashSet<string>();
var errors = new List<string>();
var coverage = new Dictionary<string, object>();
var lifetime = new System.Threading.CancellationTokenSource(TimeSpan.FromSeconds(120));
PlayerKVLoginContext context = null;
PlayerKVAccountLease lease = null;
CustomServerMgr server = null;
KVUserService user = null;
SignalRService realtime = null;
var realtimeTasks = new List<Task>();
string realtimeStep = "not-started";
int realtimeReplies = 0;
string failure = null;
bool restored = false;
int assertions = 0, offlineAssertions = 0, pfTransport = 0;
EditorApplication.CallbackFunction observePlay = () =>
{
if (EditorApplication.isPlayingOrWillChangePlaymode)
{
lifetime.Cancel();
}
};
EditorApplication.update += observePlay;
failedFormalReadCleanup = lifetime;
void Check(bool value)
{
assertions++;
if (!value)
{
throw new InvalidOperationException("Formal read assertion failed.");
}
}
string ErrorType(Exception error)
{
return (error is System.Reflection.TargetInvocationException reflection && reflection.InnerException != null ? reflection.InnerException : error).GetType().Name;
}
async Task ObserveRealtime(Task task, bool cleanup = false)
{
realtimeTasks.Add(task);
_ = task.ContinueWith(completed =>
{
var observed = completed.Exception;
}, System.Threading.CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
var timeout = Task.Delay(cleanup ? 10000 : 30000,
cleanup ? System.Threading.CancellationToken.None : lifetime.Token);
if (await Task.WhenAny(task, timeout) != task)
{
throw new TimeoutException("Realtime observation timed out.");
}
await task;
}
System.Net.Http.HttpRequestMessage Request(int index, string route = null, string body = null)
{
return new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, route ?? PlayerKVRuntimeSelection.FormalApiUrl + FormalReadHttp.Routes[index])
{
Content = new System.Net.Http.StringContent(body ?? FormalReadHttp.Bodies[index], System.Text.Encoding.UTF8, "application/json")
};
}
async Task Offline(int scenario)
{
var calls = 0;
var paths = new List<string>();
var codes = new List<int>();
var rejected = new HashSet<string>();
using (var probe = new System.Net.Http.HttpMessageInvoker(new FormalReadHttp(new ValidationHttp(_ =>
{
calls++;
return new System.Net.Http.HttpResponseMessage(scenario == 6 ? System.Net.HttpStatusCode.Unauthorized : System.Net.HttpStatusCode.OK)
{
Content = new System.Net.Http.StringContent("{}")
};
}), new object(), paths, codes, new Dictionary<string, string>(), rejected, lifetime.Token)))
{
if (scenario == 0)
{
for (int i = 0; i < 6; i++)
{
using (var request = Request(i))
using (var response = await probe.SendAsync(request, lifetime.Token))
{
Check(response.StatusCode == System.Net.HttpStatusCode.OK);
}
}
Check(calls == 6 && rejected.Count == 0);
return;
}
if (scenario == 4 || scenario == 6)
{
using (var first = Request(0))
using (await probe.SendAsync(first, lifetime.Token))
{
}
}
var blocked = false;
using (var wrong = scenario == 1 ? Request(0, "http://example.invalid/account/Login") :
scenario == 2 ? Request(0, PlayerKVRuntimeSelection.FormalApiUrl + "playerdata/Set") :
scenario == 3 ? Request(0, body: "{\"playerId\":101}") :
scenario == 5 || scenario == 6 ? Request(1) : Request(0))
{
try
{
using (await probe.SendAsync(wrong, lifetime.Token))
{
}
}
catch (InvalidOperationException)
{
blocked = true;
}
}
Check(blocked && rejected.Count > 0 && calls == (scenario == 4 || scenario == 6 ? 1 : 0));
}
}
Newtonsoft.Json.Linq.JToken Field(Newtonsoft.Json.Linq.JToken item, string name)
{
return (item as Newtonsoft.Json.Linq.JObject)?.GetValue(name, StringComparison.OrdinalIgnoreCase);
}
System.Net.Http.HttpMessageHandler Transport(System.Net.CookieContainer cookies)
{
return new FormalReadHttp(new System.Net.Http.HttpClientHandler
{
CookieContainer = cookies,
UseCookies = true,
AllowAutoRedirect = false
}, gate, admitted, statuses, responses, transportFailures, lifetime.Token);
}
void ReadyForRead()
{
RequireIdle();
lifetime.Token.ThrowIfCancellationRequested();
Check(context.IsCurrent && lease.IsCurrent && transportFailures.Count == 0);
}
try
{
for (int i = 0; i < 7; i++)
{
await Offline(i);
}
offlineAssertions = assertions;
RequireIdle();
var api = new Uri(PlayerKVRuntimeSelection.FormalApiUrl);
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-formal-read-cache", Guid.NewGuid().ToString("N")));
context = new PlayerKVLoginContext("101", root, 1202, _ => !lifetime.IsCancellationRequested, api,
() => new game.Account.S101AccountSession(api, Transport), () => new PlayerKVGameSessionBridge(Transport));
failedFormalReadCleanup = context;
var prepared = await context.PrepareAsync(lifetime.Token);
Check(prepared.Prepared && context.IsCurrent && context.AccountDescriptor?.NewlyCreated == false && prepared.Data.Count > 0);
Check(context.TryAcquireAccountLease(PlayerKVControlledLoadCapability.CreateForGame(Transport), out lease));
var config = new RetryConfig("101");
config.Set("EventApiURL", api.AbsoluteUri);
server = new CustomServerMgr(config, _ => new ValidationHttp(request =>
{
pfTransport++;
throw new InvalidOperationException("PF transport forbidden.");
}));
server.BindKVForGame(lease);
server.EnableKVBusiness(lease.Epoch);
user = new KVUserService { customServerMgr = server };
failedFormalReadCleanup = new object[] { context, server, user, lifetime };
var isolated = new asap.core.Container();
ValidationContextAccess.Use(isolated);
ValidationContextAccess.Events = new asap.core.EventAggregator();
asap.core.ContainerExtensions.RegisterInstance<ICustomServerMgr>(isolated, server);
var flags = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic;
if (verifyRealtime)
{
ReadyForRead();
realtime = new SignalRService(server, config);
failedFormalReadCleanup = new object[] { context, server, user, lifetime, realtime, realtimeTasks };
var connectionField = typeof(SignalRService).GetField("_hubConnection", flags);
realtimeStep = "connect";
await ObserveRealtime(realtime.Connect());
Check(realtime.IsConnected);
var firstConnection = connectionField.GetValue(realtime);
ReadyForRead();
realtimeStep = "duplicate-connect";
await ObserveRealtime(realtime.Connect());
Check(realtime.IsConnected && ReferenceEquals(firstConnection, connectionField.GetValue(realtime)));
ReadyForRead();
realtimeStep = "first-test";
var firstReply = realtime.Publish("Test", "kv-migration", "101-first");
await ObserveRealtime(firstReply);
Check(firstReply.Result == "OK");
realtimeReplies++;
ReadyForRead();
realtimeStep = "disconnect";
await ObserveRealtime(realtime.Disconnect());
Check(!realtime.IsConnected);
ReadyForRead();
realtimeStep = "reconnect";
await ObserveRealtime(realtime.Connect());
Check(realtime.IsConnected && !ReferenceEquals(firstConnection, connectionField.GetValue(realtime)));
ReadyForRead();
realtimeStep = "second-test";
var secondReply = realtime.Publish("Test", "kv-migration", "101-second");
await ObserveRealtime(secondReply);
Check(secondReply.Result == "OK");
realtimeReplies++;
ReadyForRead();
realtimeStep = "release";
await ObserveRealtime(realtime.ReleaseAsync());
Check(!realtime.IsConnected);
ReadyForRead();
await ObserveRealtime(realtime.Connect());
Check(!realtime.IsConnected && connectionField.GetValue(realtime) == null);
ReadyForRead();
var afterRelease = realtime.Publish("Test", "kv-migration", "101-after-release");
await ObserveRealtime(afterRelease);
Check(afterRelease.Result == null);
ReadyForRead();
await ObserveRealtime(realtime.ReleaseAsync());
Check(admitted.Count == 2 && statuses.Count == 2 && statuses.All(value => value == 200) &&
pfTransport == 0 && transportFailures.Count == 0 && !realtime.IsConnected);
realtimeStep = "completed";
}
else
{
ReadyForRead();
var board = await new GameCore.LeadboardData { userService = user, customServerMgr = server }.GetLeadboardData("LevelB", 2);
var boardRaw = Field(Newtonsoft.Json.Linq.JObject.Parse(responses[FormalReadHttp.Routes[2]]), "leaderboard") as Newtonsoft.Json.Linq.JArray;
Check(board?.Leaderboard != null && boardRaw != null && board.Leaderboard.Count == boardRaw.Count);
for (int i = 0; i < boardRaw.Count; i++)
{
var item = board.Leaderboard[i];
var raw = boardRaw[i];
var profile = Field(raw, "profile");
Check(item.PlayFabId == (string)Field(raw, "playFabId") && item.Position == (int)Field(raw, "position") && item.StatValue == (int)Field(raw, "statValue"));
Check(item.Profile.DisplayName == (string)Field(profile, "displayName") && item.Profile.AvatarUrl == (string)Field(profile, "avatarUrl") && item.Profile.LastLogin == (DateTime?)Field(profile, "lastLogin"));
}
coverage["leaderboardCount"] = boardRaw.Count;
coverage["leaderboardNonempty"] = boardRaw.Count > 0;
ReadyForRead();
var friends = new FriendService { customServerMgr = server, userService = user };
var friendResult = await (Task<PlayFab.ClientModels.GetFriendsListResult>)typeof(FriendService).GetMethod("GetKVFriendsListAsync", flags).Invoke(friends, null);
var friendRaw = Field(Newtonsoft.Json.Linq.JObject.Parse(responses[FormalReadHttp.Routes[3]]), "friends") as Newtonsoft.Json.Linq.JArray;
Check(friendResult?.Friends != null && friendRaw != null && friendResult.Friends.Count == friendRaw.Count);
for (int i = 0; i < friendRaw.Count; i++)
{
var raw = Newtonsoft.Json.Linq.JObject.Parse((string)friendRaw[i]);
var item = friendResult.Friends[i];
var profile = Field(raw, "profile");
Check(item.FriendPlayFabId == (string)Field(raw, "playFabId"));
if (profile == null || profile.Type == Newtonsoft.Json.Linq.JTokenType.Null)
{
Check(item.Profile == null);
}
else
{
Check(item.Profile != null && item.Profile.DisplayName == (string)Field(profile, "displayName") && item.Profile.AvatarUrl == (string)Field(profile, "avatarUrl") && item.Profile.LastLogin == (DateTime?)Field(profile, "lastLogin"));
var statistics = Field(profile, "statistics") as Newtonsoft.Json.Linq.JArray;
Check(statistics == null ? item.Profile.Statistics == null : item.Profile.Statistics?.Count == statistics.Count);
if (statistics != null)
{
for (int j = 0; j < statistics.Count; j++)
{
if (statistics[j].Type == Newtonsoft.Json.Linq.JTokenType.Null)
{
Check(item.Profile.Statistics[j] == null);
}
else
{
Check(item.Profile.Statistics[j].Name == (string)Field(statistics[j], "name") && item.Profile.Statistics[j].Value == (int)Field(statistics[j], "value"));
}
}
}
}
}
coverage["friendCount"] = friendRaw.Count;
coverage["friendNonempty"] = friendRaw.Count > 0;
ReadyForRead();
var news = new TileNewsManager();
var newsResult = await (Task<PlayFab.ClientModels.GetTitleNewsResult>)typeof(TileNewsManager).GetMethod("GetKVTitleNewsAsync", flags).Invoke(news, null);
var newsRaw = Field(Newtonsoft.Json.Linq.JObject.Parse(responses[FormalReadHttp.Routes[4]]), "news") as Newtonsoft.Json.Linq.JArray;
Check(newsResult?.News != null && newsRaw != null && newsResult.News.Count == newsRaw.Count);
for (int i = 0; i < newsRaw.Count; i++)
{
var item = newsResult.News[i];
var raw = newsRaw[i];
if (raw.Type == Newtonsoft.Json.Linq.JTokenType.Null)
{
Check(item == null);
}
else
{
Check(item.NewsId == (string)Field(raw, "newsId") && item.Title == (string)Field(raw, "title") && item.Body == (string)Field(raw, "body") && item.Timestamp == (DateTime)Field(raw, "timestamp"));
}
}
coverage["newsCount"] = newsRaw.Count;
coverage["newsNonempty"] = newsRaw.Count > 0;
ReadyForRead();
var level = await user.GetPlayLv("102");
var levelRaw = Newtonsoft.Json.Linq.JObject.Parse(responses[FormalReadHttp.Routes[5]]);
var publicProfile = Field(levelRaw, "kvProfile") as Newtonsoft.Json.Linq.JObject;
Check((int)Field(levelRaw, "code") > 0 && publicProfile != null);
var levelToken = Field(publicProfile, "level");
var explicitLevel = levelToken != null && levelToken.Type != Newtonsoft.Json.Linq.JTokenType.Null;
Check(!explicitLevel || levelToken.Type == Newtonsoft.Json.Linq.JTokenType.Integer);
var expectedLevel = explicitLevel ? (int)levelToken : 1;
Check(level.Item1 == "102" && level.Item2 == expectedLevel && expectedLevel >= 0 && user.GetPlayerLv("102") == expectedLevel);
var cached = await user.GetPlayLv("102");
Check(cached.Equals(level) && admitted.Count == 6 && statuses.Count == 6 && statuses.All(value => value == 200) && pfTransport == 0 && transportFailures.Count == 0);
coverage["publicLevelExplicit"] = explicitLevel;
coverage["publicLevelDefaultApplied"] = !explicitLevel;
}
}
catch (Exception ex)
{
failure = ErrorType(ex);
}
finally
{
async Task Cleanup(Func<Task> action)
{
try
{
await action();
}
catch (Exception ex)
{
errors.Add(ErrorType(ex));
}
}
if (realtime != null)
{
await Cleanup(() => ObserveRealtime(realtime.ReleaseAsync(), true));
await Cleanup(async () =>
{
var all = Task.WhenAll(realtimeTasks.ToArray());
try
{
await ObserveRealtime(all, true);
}
catch
{
if (!all.IsCompleted)
{
throw;
}
}
});
}
await Cleanup(() =>
{
lifetime.Cancel();
return Task.CompletedTask;
});
await Cleanup(() =>
{
server?.DisableKVBusiness();
return Task.CompletedTask;
});
await Cleanup(() => context?.CloseAsync() ?? Task.CompletedTask);
await Cleanup(() => server?.ClearKVForGame() ?? Task.CompletedTask);
await Cleanup(() => user?.CloseKVForValidationAsync() ?? Task.CompletedTask);
await Cleanup(() =>
{
ValidationContextAccess.Use(originalContainer);
return Task.CompletedTask;
});
await Cleanup(() =>
{
ValidationContextAccess.Events = originalEvents;
return Task.CompletedTask;
});
await Cleanup(() =>
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
return Task.CompletedTask;
});
await Cleanup(() =>
{
EditorApplication.update -= observePlay;
return Task.CompletedTask;
});
await Cleanup(() =>
{
lifetime.Dispose();
return Task.CompletedTask;
});
restored = errors.Count == 0 && (context == null || !context.IsCurrent) && (lease == null || !lease.IsCurrent) &&
ReferenceEquals(asap.core.GContext.container, originalContainer) && ReferenceEquals(ValidationContextAccess.Events, originalEvents) &&
ReferenceEquals(System.Threading.SynchronizationContext.Current, originalContext) && instanceField.GetValue(null) == null;
restored = restored && (realtime == null || !realtime.IsConnected) && realtimeTasks.All(task => task.IsCompleted);
if (restored)
{
failedFormalReadCleanup = null;
}
running = false;
}
if (verifyRealtime)
{
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P14-FormalRealtime",
assertions, offlineAssertions, routes = admitted, statuses, realtimeStep, realtimeReplies, pfTransport,
restored, failure, cleanupErrors = errors, transportFailures, formalRequests = admitted.Count,
businessWrites = 0, remainingRealtimeTasks = realtimeTasks.Count(task => !task.IsCompleted),
actualSignalRService = true, automaticReconnectVerified = false, naturalUIVerified = false });
}
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P12B-FormalReadAdapters", assertions, offlineAssertions,
routes = admitted, statuses, coverage, pfTransport, restored, failure, cleanupErrors = errors, transportFailures,
formalRequests = admitted.Count, businessWrites = 0, actualTaskAdapters = true, naturalUIVerified = false });
}
private static object failedFormalMatchCleanup;
private sealed class FormalMatchHttp : System.Net.Http.DelegatingHandler
{
private readonly Func<System.Net.Http.HttpRequestMessage, string, System.Threading.CancellationToken> admit;
private readonly Action<string, int, string> receive;
internal FormalMatchHttp(System.Net.Http.HttpMessageHandler inner,
Func<System.Net.Http.HttpRequestMessage, string, System.Threading.CancellationToken> admit,
Action<string, int, string> receive)
{
InnerHandler = inner;
this.admit = admit;
this.receive = receive;
}
protected override async Task<System.Net.Http.HttpResponseMessage> SendAsync(
System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken token)
{
var body = await request.Content.ReadAsStringAsync();
var admittedToken = admit(request, body);
using (var linked = System.Threading.CancellationTokenSource.CreateLinkedTokenSource(token, admittedToken))
{
var response = await base.SendAsync(request, linked.Token);
try
{
var text = await response.Content.ReadAsStringAsync();
receive(request.RequestUri.AbsolutePath.TrimStart('/'), (int)response.StatusCode, text);
return response;
}
catch
{
response.Dispose();
throw;
}
}
}
}
private static async Task<string> RunFormalMatchmaking(bool stateOnly = false)
{
var began = DateTime.UtcNow;
var mainDeadline = began.AddSeconds(100);
var finalDeadline = began.AddSeconds(170);
var instance = typeof(KVMgr).GetField("instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
void Idle()
{
if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating ||
asap.core.GContext.Ready || PlayerKVGameplayLoop.Enabled || instance.GetValue(null) != null ||
UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 ||
PlayerKVShutdownRegistry.Process.Status != PlayerKVShutdownStatus.Ready)
{
throw new InvalidOperationException("Formal matchmaking requires an idle Editor.");
}
}
Idle();
if (running || failedFormalReadCleanup != null || failedMatchmakingCleanup != null || failedFormalMatchCleanup != null)
{
throw new InvalidOperationException("Previous validation has not closed.");
}
running = true;
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var originalContext = System.Threading.SynchronizationContext.Current;
var observed = new LeaderboardContext(originalContext);
var identity = new System.Threading.CancellationTokenSource();
var main = new System.Threading.CancellationTokenSource(TimeSpan.FromSeconds(100));
System.Threading.CancellationTokenSource cleanupToken = null;
var stateGate = new object();
var phase = main.Token;
var phaseDeadline = mainDeadline;
var contexts = new PlayerKVLoginContext[2];
var leases = new PlayerKVAccountLease[2];
var servers = new CustomServerMgr[2];
var containers = new asap.core.Container[2];
var expected = new[] { new Queue<(string route, Newtonsoft.Json.Linq.JToken body)>(), new Queue<(string route, Newtonsoft.Json.Linq.JToken body)>() };
var tickets = new Dictionary<string, (int owner, string status)>();
var unknown = new int[2];
var tasks = new List<Task>();
var requests = new List<object>();
var statuses = new List<int>();
var errors = new List<string>();
var queue = "P15_" + Guid.NewGuid().ToString("N");
var api = new Uri(PlayerKVRuntimeSelection.FormalApiUrl);
var flags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static;
var requestMethod = typeof(EventFishingDuelPanel).GetMethod("RequestKVMatch", flags);
var readMatch = (Func<Newtonsoft.Json.Linq.JObject, PlayFab.MultiplayerModels.GetMatchResult>)Delegate.CreateDelegate(
typeof(Func<Newtonsoft.Json.Linq.JObject, PlayFab.MultiplayerModels.GetMatchResult>), typeof(EventFishingDuelPanel).GetMethod("ReadKVMatch", flags));
int assertions = 0, offlineAssertions = 0, pfTransport = 0, matchesRead = 0;
string failure = null;
bool restored = false;
EditorApplication.CallbackFunction watch = () =>
{
if (EditorApplication.isPlayingOrWillChangePlaymode)
{
main.Cancel();
}
};
EditorApplication.update += watch;
failedFormalMatchCleanup = new object[] { contexts, leases, servers, containers, observed, tasks, identity, main, tickets, unknown, queue, stateGate, expected, requests, statuses, errors };
void Check(bool value)
{
assertions++;
if (!value)
{
throw new InvalidOperationException("Formal matchmaking assertion failed.");
}
}
void Track(Task task)
{
tasks.Add(task);
_ = task.ContinueWith(done =>
{
var seen = done.Exception;
}, System.Threading.CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}
async Task Until(Task task, DateTime deadline)
{
Track(task);
var remaining = deadline - DateTime.UtcNow;
if (remaining <= TimeSpan.Zero || await Task.WhenAny(task, Task.Delay(remaining)) != task)
{
throw new TimeoutException("Formal matchmaking observation timed out.");
}
await task;
}
async Task Drain(DateTime deadline)
{
await Until(observed.WaitForIdle(), deadline);
var posted = new TaskCompletionSource<bool>();
observed.Post(_ => posted.TrySetResult(true), null);
await Until(posted.Task, deadline);
}
void Permit(int who, string route, object body)
{
var value = Newtonsoft.Json.Linq.JToken.FromObject(body);
lock (stateGate)
{
expected[who].Enqueue((route, value));
}
}
int Pending(int who)
{
lock (stateGate)
{
return expected[who].Count;
}
}
void ClearPermits(int who)
{
lock (stateGate)
{
expected[who].Clear();
}
}
System.Threading.CancellationToken Admit(int who, System.Net.Http.HttpRequestMessage request, string body)
{
var value = Newtonsoft.Json.Linq.JToken.Parse(body);
lock (stateGate)
{
phase.ThrowIfCancellationRequested();
if (expected[who].Count == 0)
{
throw new InvalidOperationException("Unplanned formal request.");
}
var next = expected[who].Dequeue();
if (request.Method != System.Net.Http.HttpMethod.Post || request.RequestUri.AbsoluteUri != api.AbsoluteUri + next.route ||
!Newtonsoft.Json.Linq.JToken.DeepEquals(next.body, value))
{
throw new InvalidOperationException("Formal request does not match its permit.");
}
if (next.route == "matchmaking/CreateMatchmakingTicket")
{
unknown[who]++;
}
return phase;
}
}
void Receive(int who, string route, int status, string text)
{
string ticket = null;
if (route == "matchmaking/CreateMatchmakingTicket" && status == 200)
{
var value = Newtonsoft.Json.Linq.JObject.Parse(text);
if ((int?)value["code"] == 1)
{
ticket = (string)value["ticketId"];
}
}
lock (stateGate)
{
requests.Add(new { account = 101 + who, route, status });
statuses.Add(status);
if (!string.IsNullOrEmpty(ticket) && !tickets.ContainsKey(ticket))
{
tickets.Add(ticket, (who, "unconfirmed"));
unknown[who]--;
}
}
}
(int owner, string status) Ticket(string id)
{
lock (stateGate)
{
return tickets[id];
}
}
(object[] requests, KeyValuePair<string, (int owner, string status)>[] tickets, int unknown, int[] statuses) Snapshot()
{
lock (stateGate)
{
return (requests.ToArray(), tickets.ToArray(), unknown.Sum(), statuses.ToArray());
}
}
System.Net.Http.HttpMessageHandler Transport(int who, System.Net.CookieContainer cookies)
{
return new FormalMatchHttp(new System.Net.Http.HttpClientHandler
{
CookieContainer = cookies, UseCookies = true, AllowAutoRedirect = false
}, (request, body) => Admit(who, request, body), (route, status, text) => Receive(who, route, status, text));
}
async Task<T> Call<T>(int who, string action, object body, Func<Newtonsoft.Json.Linq.JObject, T> parse)
{
Idle();
phase.ThrowIfCancellationRequested();
Check(DateTime.UtcNow < phaseDeadline && observed.Active == 0 && contexts[who].IsCurrent && leases[who].IsCurrent && Pending(who) == 0);
ValidationContextAccess.Use(containers[who]);
Permit(who, "matchmaking/" + action, body);
var result = new MatchCallback<T>();
var started = observed.Started;
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
requestMethod.MakeGenericMethod(typeof(T)).Invoke(null, new object[] { action, body, parse,
new Action<T>(value =>
{
result.Success++;
result.Value = value;
}),
new Action<string>(_ =>
{
result.Failure++;
}) });
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
}
Check(observed.Started == started + 1);
await Drain(phaseDeadline);
Check(result.Success == 1 && result.Failure == 0 && observed.Errors.Count == 0 && Pending(who) == 0);
return result.Value;
}
object Attributes(int who)
{
return new
{
Tier = new[] { "1" }, Map = new[] { "p15-common-map" }, Group = new[] { "p15" },
Details = JsonConvert.SerializeObject(new { ID = (101 + who).ToString(CultureInfo.InvariantCulture), Name = "KV migration test", Avatar = "", RandScore = 0, Mag = 1 })
};
}
async Task<string> Create(int who)
{
var result = await Call(who, "CreateMatchmakingTicket", new { queueName = queue, giveUpAfterSeconds = 60, attributes = Attributes(who) },
value => value.ToObject<PlayFab.MultiplayerModels.CreateMatchmakingTicketResult>());
Check(!string.IsNullOrEmpty(result.TicketId) && Snapshot().tickets.Any(item => item.Key == result.TicketId && item.Value.owner == who));
return result.TicketId;
}
async Task<PlayFab.MultiplayerModels.GetMatchmakingTicketResult> ReadTicket(string ticket)
{
var owner = Ticket(ticket).owner;
var result = await Call(owner, "GetMatchmakingTicket", new { queueName = queue, ticketId = ticket },
value => value.ToObject<PlayFab.MultiplayerModels.GetMatchmakingTicketResult>());
lock (stateGate)
{
tickets[ticket] = (owner, result.Status);
}
return result;
}
async Task Cancel(string ticket)
{
await Call(Ticket(ticket).owner, "CancelMatchmakingTicket", new { queueName = queue, ticketId = ticket },
value => value.ToObject<PlayFab.MultiplayerModels.CancelMatchmakingTicketResult>());
}
async Task Cleanup(Func<Task> action)
{
try
{
await action();
}
catch (Exception error)
{
errors.Add(error.GetType().Name);
}
}
try
{
for (int scenario = 0; scenario < 5; scenario++)
{
ClearPermits(0);
Permit(0, "account/Login", new { playerId = "101" });
int sent = 0;
using (var probe = new System.Net.Http.HttpMessageInvoker(new FormalMatchHttp(new ValidationHttp(_ =>
{
sent++;
return ValidationJson(new { });
}), (request, body) => Admit(0, request, body), (_, __, ___) =>
{
})))
{
var route = scenario == 0 ? "http://example.invalid/account/Login" : api.AbsoluteUri + (scenario == 1 ? "playerdata/Set" : "account/Login");
var body = scenario == 2 ? "{\"playerId\":\"102\"}" : "{\"playerId\":\"101\"}";
bool blocked = false;
using (var request = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, route)
{
Content = new System.Net.Http.StringContent(body)
})
{
try
{
using (await probe.SendAsync(request, phase))
{
}
}
catch (InvalidOperationException)
{
blocked = true;
}
}
if (scenario == 4)
{
using (var duplicate = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, route)
{
Content = new System.Net.Http.StringContent(body)
})
{
try
{
using (await probe.SendAsync(duplicate, phase))
{
}
}
catch (InvalidOperationException)
{
blocked = true;
}
}
}
Check(scenario < 3 ? blocked && sent == 0 : scenario == 3 ? !blocked && sent == 1 : blocked && sent == 1);
}
}
ClearPermits(0);
// Exercise the same receive/snapshot functions while a background response arrives.
Receive(0, "playerdata/Get", 200, "{}");
var held = Snapshot();
var late = Task.Run(() =>
{
for (int i = 0; i < 200; i++)
{
Receive(1, "playerdata/Get", 200, "{}");
}
});
for (int i = 0; i < 200; i++)
{
var copy = Snapshot();
Check(copy.requests.Length == copy.statuses.Length);
JsonConvert.SerializeObject(copy.requests);
}
await Until(late, phaseDeadline);
Check(held.requests.Length == 1 && Snapshot().requests.Length == 201);
Check(held.tickets.Length == 0 && held.unknown == 0);
// A permit captures the original phase token even after the phase changes.
Permit(0, "account/Login", new { playerId = "101" });
using (var probe = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Post, api.AbsoluteUri + "account/Login"))
{
var captured = Admit(0, probe, "{\"playerId\":\"101\"}");
using (var nextPhase = new System.Threading.CancellationTokenSource())
{
lock (stateGate)
{
phase = nextPhase.Token;
}
nextPhase.Cancel();
Check(captured == main.Token && !captured.IsCancellationRequested);
lock (stateGate)
{
phase = main.Token;
}
}
}
lock (stateGate)
{
requests.Clear();
statuses.Clear();
}
offlineAssertions = assertions;
if (!stateOnly)
{
ValidationContextAccess.Events = new asap.core.EventAggregator();
for (int who = 0; who < 2; who++)
{
int owner = who;
string id = (101 + who).ToString(CultureInfo.InvariantCulture);
Permit(who, "account/Login", new { playerId = id });
Permit(who, "playerdata/Get", new { });
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-formal-match-cache", Guid.NewGuid().ToString("N")));
contexts[who] = new PlayerKVLoginContext(id, root, 1500 + who, _ => !identity.IsCancellationRequested, api,
() => new game.Account.S101AccountSession(api, cookies => Transport(owner, cookies)),
() => new PlayerKVGameSessionBridge(cookies => Transport(owner, cookies)));
var prepare = contexts[who].PrepareAsync(identity.Token);
await Until(prepare, phaseDeadline);
Check(prepare.Result.Prepared && contexts[who].IsCurrent && contexts[who].AccountDescriptor?.NewlyCreated == false && prepare.Result.Data.Count > 0 && Pending(who) == 0);
Check(contexts[who].TryAcquireAccountLease(PlayerKVControlledLoadCapability.CreateForGame(cookies => Transport(owner, cookies)), out leases[who]));
var config = new RetryConfig(id);
config.Set("EventApiURL", api.AbsoluteUri);
servers[who] = new CustomServerMgr(config, _ => new ValidationHttp(request =>
{
pfTransport++;
throw new InvalidOperationException("PF transport forbidden.");
}));
servers[who].BindKVForGame(leases[who]);
servers[who].EnableKVBusiness(leases[who].Epoch);
containers[who] = new asap.core.Container();
asap.core.ContainerExtensions.RegisterInstance<ICustomServerMgr>(containers[who], servers[who]);
}
var a = await Create(0);
Check((await ReadTicket(a)).Status == "WaitingForMatch");
await Cancel(a);
var canceled = await ReadTicket(a);
Check(canceled.Status == "Canceled" && canceled.CancellationReasonString == "Requested");
var b = await Create(0);
var c = await Create(1);
var first = await ReadTicket(b);
var second = await ReadTicket(c);
Check(first.Status == "Matched" && second.Status == "Matched" && !string.IsNullOrEmpty(first.MatchId) && first.MatchId == second.MatchId);
for (int who = 0; who < 2; who++)
{
var match = await Call(who, "GetMatch", new { queueName = queue, matchId = first.MatchId }, readMatch);
Check(match.MatchId == first.MatchId && match.Members?.Count == 2);
Check(match.Members.Select(member => member.Entity.Id).OrderBy(value => value).SequenceEqual(new[] { "101", "102" }));
foreach (var member in match.Members)
{
int owner = member.Entity.Id == "101" ? 0 : 1;
Check(Newtonsoft.Json.Linq.JToken.DeepEquals(Newtonsoft.Json.Linq.JToken.FromObject(member.Attributes.DataObject), Newtonsoft.Json.Linq.JToken.FromObject(Attributes(owner))));
}
matchesRead++;
}
var complete = Snapshot();
Check(complete.requests.Length == 14 && complete.statuses.All(status => status == 200) && pfTransport == 0 && complete.unknown == 0);
}
}
catch (Exception error)
{
failure = error.GetType().Name;
}
finally
{
main.Cancel();
var drainDeadline = DateTime.UtcNow.AddSeconds(20);
if (drainDeadline > finalDeadline)
{
drainDeadline = finalDeadline;
}
await Cleanup(() => Drain(drainDeadline));
if (observed.Active == 0)
{
cleanupToken = new System.Threading.CancellationTokenSource(TimeSpan.FromSeconds(40));
lock (stateGate)
{
phase = cleanupToken.Token;
}
phaseDeadline = DateTime.UtcNow.AddSeconds(40);
if (phaseDeadline > finalDeadline.AddSeconds(-10))
{
phaseDeadline = finalDeadline.AddSeconds(-10);
}
for (int who = 0; who < 2; who++)
{
ClearPermits(who);
}
foreach (var ticket in Snapshot().tickets.Select(item => item.Key))
{
if (Ticket(ticket).status == "Canceled" || Ticket(ticket).status == "Matched")
{
continue;
}
await Cleanup(async () =>
{
var current = await ReadTicket(ticket);
if (current.Status == "WaitingForMatch")
{
await Cancel(ticket);
current = await ReadTicket(ticket);
}
Check(current.Status == "Canceled" || current.Status == "Matched");
});
if (observed.Active != 0 || DateTime.UtcNow >= phaseDeadline)
{
break;
}
}
}
cleanupToken?.Cancel();
identity.Cancel();
var closing = new List<Task>();
for (int who = 0; who < 2; who++)
{
int owner = who;
var close = Cleanup(async () =>
{
await Cleanup(() =>
{
servers[owner]?.DisableKVBusiness();
return Task.CompletedTask;
});
await Cleanup(() => contexts[owner]?.CloseAsync() ?? Task.CompletedTask);
await Cleanup(() => servers[owner]?.ClearKVForGame() ?? Task.CompletedTask);
});
Track(close);
closing.Add(close);
}
var end = DateTime.UtcNow.AddSeconds(10);
if (end > finalDeadline)
{
end = finalDeadline;
}
await Cleanup(() => Until(Task.WhenAll(closing), end));
await Cleanup(() => Drain(end));
if (observed.Active == 0 && tasks.All(task => task.IsCompleted))
{
ValidationContextAccess.Use(originalContainer);
ValidationContextAccess.Events = originalEvents;
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
restored = errors.Count == 0 && observed.Errors.Count == 0 && contexts.All(value => value == null || !value.IsCurrent) &&
leases.All(value => value == null || !value.IsCurrent) && instance.GetValue(null) == null;
}
EditorApplication.update -= watch;
if (restored)
{
failedFormalMatchCleanup = null;
identity.Dispose();
main.Dispose();
cleanupToken?.Dispose();
}
running = false;
}
var final = Snapshot();
var errorSnapshot = errors.ToArray();
var taskSnapshot = tasks.ToArray();
var callbackSnapshot = observed.Errors.Select(value => value.GetType().Name).ToArray();
var waiting = final.tickets.Count(item => item.Value.status != "Canceled" && item.Value.status != "Matched");
var serverCleanupComplete = final.unknown == 0 && waiting == 0;
return JsonConvert.SerializeObject(new
{
success = failure == null && errorSnapshot.Length == 0 && restored && serverCleanupComplete,
caseId = stateOnly ? "P15-FormalMatchState" : "P15-FormalMatchmaking", assertions, offlineAssertions, requests = final.requests, pfTransport, businessWrites = 0, stateOnly,
matchesRead, unknownCreations = final.unknown, waitingTickets = waiting, retainedTerminalTickets = final.tickets.Length - waiting,
retainedMatchRecords = final.tickets.Any(item => item.Value.status == "Matched") ? 1 : 0, serverCleanupComplete,
restored, failure, cleanupErrors = errorSnapshot, callbackErrors = callbackSnapshot,
remainingCallbacks = observed.Active, remainingTasks = taskSnapshot.Count(task => !task.IsCompleted),
isolatedQueue = queue, tickets = final.tickets.Select(item => new { id = item.Key, account = 101 + item.Value.owner, status = item.Value.status }).ToArray(),
controlledAttributes = true, naturalUIVerified = false, globalMapRuleVerified = false
});
}
private static object failedMatchmakingCleanup;
private sealed class MatchCallback<T>
{
internal int Success;
internal int Failure;
internal T Value;
}
private static async Task<string> RunMatchmaking()
{
const System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic;
var instanceField = typeof(KVMgr).GetField("instance", flags);
if (running || failedMatchmakingCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || asap.core.GContext.Ready ||
PlayerKVGameplayLoop.Enabled || instanceField.GetValue(null) != null ||
UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0)
{
throw new InvalidOperationException("Matchmaking validation requires an idle isolated Editor.");
}
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var originalContext = System.Threading.SynchronizationContext.Current;
var observed = new LeaderboardContext(originalContext);
var errors = new List<string>();
var expectedErrors = new HashSet<Exception>();
var releases = new List<TaskCompletionSource<System.Net.Http.HttpResponseMessage>>();
var holds = new Queue<TaskCompletionSource<System.Net.Http.HttpResponseMessage>>();
PlayerKVLoginContext context = null;
CustomServerMgr server = null;
KVUserService user = null;
string failure = null;
bool restored = false;
int assertions = 0, sends = 0, auth = 0, gets = 0, pfTransport = 0;
var requestMethod = typeof(EventFishingDuelPanel).GetMethod("RequestKVMatch", flags);
var readMatch = (Func<Newtonsoft.Json.Linq.JObject, PlayFab.MultiplayerModels.GetMatchResult>)
Delegate.CreateDelegate(typeof(Func<Newtonsoft.Json.Linq.JObject, PlayFab.MultiplayerModels.GetMatchResult>),
typeof(EventFishingDuelPanel).GetMethod("ReadKVMatch", flags));
running = true;
void Check(bool condition, string detail)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("Matchmaking: " + detail);
}
}
MatchCallback<T> Start<T>(string action, object request, Func<Newtonsoft.Json.Linq.JObject, T> parse,
Exception successError = null, Exception failureError = null)
{
var record = new MatchCallback<T>();
Action<T> success = value =>
{
record.Success++;
record.Value = value;
if (successError != null)
{
throw successError;
}
};
Action<string> failed = error =>
{
record.Failure++;
Check(!string.IsNullOrEmpty(error), "failure is explained");
if (failureError != null)
{
throw failureError;
}
};
var started = observed.Started;
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
requestMethod.MakeGenericMethod(typeof(T)).Invoke(null, new object[] { action, request, parse, success, failed });
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
}
Check(observed.Started == started + 1, "real callback transport async void entered once");
return record;
}
async Task Drain()
{
await observed.WaitForIdle();
// Queue after async-void exception posts, so their observer has also run before assertions/restoration.
var drained = new TaskCompletionSource<bool>();
observed.Post(_ => drained.TrySetResult(true), null);
await drained.Task;
}
try
{
var api = new Uri(PlayerKVRuntimeSelection.FormalApiUrl);
var config = new RetryConfig("101");
config.Set("EventApiURL", api.AbsoluteUri);
string body = "{\"code\":1,\"ticketId\":\"ticket-101\"}";
var status = System.Net.HttpStatusCode.OK;
string lastRoute = null;
Newtonsoft.Json.Linq.JObject sent = null;
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-matchmaking-cache", Guid.NewGuid().ToString("N")));
context = new PlayerKVLoginContext("101", root, 804, _ => true, api,
() => new game.Account.S101AccountSession(api, cookies => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "account/Login"), "fake authentication route");
auth++;
cookies.Add(api, new System.Net.Cookie("sid", "synthetic"));
return ValidationJson(new { state = 0, internalId = 101, newCreate = false,
createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
})),
() => new PlayerKVGameSessionBridge(_ => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "playerdata/Get"), "fake own KV route");
gets++;
return ValidationJson(new { data = new Dictionary<string, string>() });
})));
Check((await context.PrepareAsync()).Prepared, "real context prepared");
Check(context.TryAcquireAccountLease(PlayerKVControlledLoadCapability.CreateForGame(_ => new ValidationHttp(null, async request =>
{
Check(request.Method == System.Net.Http.HttpMethod.Post && request.RequestUri.GetLeftPart(UriPartial.Authority) == "http://s101.local:18080", "fixed POST origin");
lastRoute = request.RequestUri.AbsolutePath;
Check(new[] { "/matchmaking/CreateMatchmakingTicket", "/matchmaking/GetMatchmakingTicket",
"/matchmaking/CancelMatchmakingTicket", "/matchmaking/GetMatch" }.Contains(lastRoute), "only four published routes");
sends++;
sent = Newtonsoft.Json.Linq.JObject.Parse(await request.Content.ReadAsStringAsync());
if (holds.Count != 0)
{
return await holds.Dequeue().Task;
}
return new System.Net.Http.HttpResponseMessage(status) { Content = new System.Net.Http.StringContent(body) };
})), out var lease), "real account lease");
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
server = new CustomServerMgr(config, _ => new ValidationHttp(request =>
{
pfTransport++;
throw new InvalidOperationException("PF transport forbidden");
}));
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
}
server.BindKVForGame(lease);
server.EnableKVBusiness(lease.Epoch);
user = new KVUserService { customServerMgr = server };
var isolated = new asap.core.Container();
ValidationContextAccess.Use(isolated);
ValidationContextAccess.Events = new asap.core.EventAggregator();
asap.core.ContainerExtensions.RegisterInstance<IUserService>(isolated, user);
asap.core.ContainerExtensions.RegisterInstance<ICustomServerMgr>(isolated, server);
var details = "{\"ID\":\"101\",\"Name\":\"name\",\"Avatar\":\"avatar\",\"RandScore\":1,\"Mag\":2}";
var createRequest = new { queueName = "DuelPVP", giveUpAfterSeconds = 30,
attributes = new { Tier = new[] { "1" }, Map = new[] { "10", "11" }, Group = new[] { "0" }, Details = details } };
var ticketRequest = new { queueName = "DuelPVP", ticketId = "ticket-101" };
var matchRequest = new { queueName = "DuelPVP", matchId = "match-101-102" };
Func<Newtonsoft.Json.Linq.JObject, PlayFab.MultiplayerModels.CreateMatchmakingTicketResult> createParse = value => value.ToObject<PlayFab.MultiplayerModels.CreateMatchmakingTicketResult>();
var created = Start("CreateMatchmakingTicket", createRequest, createParse);
await Drain();
Check(created.Success == 1 && created.Failure == 0 && created.Value.TicketId == "ticket-101", "create callback exact ticket");
Check(lastRoute.EndsWith("CreateMatchmakingTicket") && sent.Count == 3 && (string)sent["queueName"] == "DuelPVP" &&
(int)sent["giveUpAfterSeconds"] == 30 && (string)sent["attributes"]["Details"] == details &&
sent["attributes"]["Tier"] is Newtonsoft.Json.Linq.JArray && (string)sent["attributes"]["Map"][1] == "11" &&
(string)sent["attributes"]["Group"][0] == "0", "original attributes and Details string");
foreach (var ticketStatus in new[] { "WaitingForMatch", "Matched", "Canceled", "UnknownStatus" })
{
body = JsonConvert.SerializeObject(new { code = 1, status = ticketStatus, matchId = "match-101-102", cancellationReasonString = "Requested" });
var ticket = Start("GetMatchmakingTicket", ticketRequest, value => value.ToObject<PlayFab.MultiplayerModels.GetMatchmakingTicketResult>());
await Drain();
Check(ticket.Success == 1 && ticket.Failure == 0 && ticket.Value.Status == ticketStatus &&
ticket.Value.MatchId == "match-101-102" && ticket.Value.CancellationReasonString == "Requested", "status/reason preserved, no new state rules");
Check(sent.Count == 2 && (string)sent["ticketId"] == "ticket-101", "ticket request fields");
}
body = "{\"code\":1}";
var canceled = Start("CancelMatchmakingTicket", ticketRequest, value => value.ToObject<PlayFab.MultiplayerModels.CancelMatchmakingTicketResult>());
await Drain();
Check(canceled.Success == 1 && canceled.Failure == 0 && lastRoute.EndsWith("CancelMatchmakingTicket"), "cancel callback and route");
body = JsonConvert.SerializeObject(new { code = 1, matchId = "match-101-102", members = new[]
{
new { playerId = "101", attributes = new { Tier = new[] { "1" }, Map = new[] { "10", "11" }, Group = new[] { "0" }, Details = details } },
new { playerId = "102", attributes = new { Tier = new[] { "1" }, Map = new[] { "11" }, Group = new[] { "0" }, Details = "{\"ID\":\"102\"}" } }
} });
var validMatch = body;
var matched = Start("GetMatch", matchRequest, readMatch);
await Drain();
Check(matched.Success == 1 && matched.Failure == 0 && matched.Value.Members.Count == 2 &&
matched.Value.Members[0].Entity.Id == "101" && matched.Value.Members[1].Entity.Id == "102", "new UserID mapped without PF credentials");
var attributes = (Newtonsoft.Json.Linq.JObject)matched.Value.Members[1].Attributes.DataObject;
Check(attributes["Details"].Type == Newtonsoft.Json.Linq.JTokenType.String && (string)attributes["Details"] == "{\"ID\":\"102\"}" &&
(string)attributes["Map"][0] == "11" && attributes["map"] == null && (string)sent["matchId"] == "match-101-102", "exact member attributes and requested match");
body = validMatch.Replace("[\"11\"]", "[\"99\"]");
matched = Start("GetMatch", matchRequest, readMatch);
await Drain();
Check((string)((Newtonsoft.Json.Linq.JObject)matched.Value.Members[1].Attributes.DataObject)["Map"][0] == "99", "disjoint maps not silently repaired by client mapping");
foreach (var members in new[] { "", ",\"members\":null", ",\"members\":[]" })
{
body = "{\"code\":1,\"matchId\":\"m\"" + members + "}";
matched = Start("GetMatch", matchRequest, readMatch);
await Drain();
Check(matched.Success == 1 && matched.Failure == 0 && (members.EndsWith("[]") ? matched.Value.Members.Count == 0 : matched.Value.Members == null), "missing/null/empty original members behavior");
}
foreach (var invalid in new[] { "", "null", "[]", "{", "{\"code\":0}", "{}", "{\"code\":\"bad\"}",
"{\"code\":1,\"members\":{}}", "{\"code\":1,\"members\":[null]}",
"{\"code\":1,\"members\":[{\"playerId\":\"102\"}]}", "{\"code\":1,\"members\":[{\"attributes\":{}}]}" })
{
body = invalid;
matched = Start("GetMatch", matchRequest, readMatch);
await Drain();
Check(matched.Success == 0 && matched.Failure == 1, "invalid response yields exactly one failure");
}
body = validMatch;
foreach (var http in new[] { System.Net.HttpStatusCode.InternalServerError, System.Net.HttpStatusCode.Conflict })
{
status = http;
canceled = Start("CancelMatchmakingTicket", ticketRequest, value => value.ToObject<PlayFab.MultiplayerModels.CancelMatchmakingTicketResult>());
await Drain();
Check(canceled.Success == 0 && canceled.Failure == 1, "HTTP failure/409 stays failure, no retry");
}
status = System.Net.HttpStatusCode.OK;
var successError = new InvalidOperationException("Expected P8D success callback exception");
expectedErrors.Add(successError);
matched = Start("GetMatch", matchRequest, readMatch, successError);
await Drain();
Check(matched.Success == 1 && matched.Failure == 0 && observed.Errors.Contains(successError), "success callback error is not converted into second failure");
body = "{\"code\":0}";
var failureError = new InvalidOperationException("Expected P8D failure callback exception");
expectedErrors.Add(failureError);
matched = Start("GetMatch", matchRequest, readMatch, null, failureError);
await Drain();
Check(matched.Success == 0 && matched.Failure == 1 && observed.Errors.Contains(failureError), "failure callback error is not called twice");
var held = new TaskCompletionSource<System.Net.Http.HttpResponseMessage>();
releases.Add(held);
holds.Enqueue(held);
var late = Start("GetMatch", matchRequest, readMatch);
Check(observed.Active == 1 && late.Success == 0 && late.Failure == 0, "delayed operation is active");
status = System.Net.HttpStatusCode.Unauthorized;
matched = Start("GetMatch", matchRequest, readMatch);
Check(matched.Success == 0 && matched.Failure == 1, "401 yields original failure callback");
held.SetResult(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) { Content = new System.Net.Http.StringContent(validMatch) });
await Drain();
Check(late.Success == 0 && late.Failure == 1, "late success after real lease revocation is rejected once");
Check(pfTransport == 0 && auth == 1 && gets == 1 && !user.IsAuthorized, "fake requests only without published gameplay authorization");
}
catch (Exception ex)
{
failure = ex.ToString();
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
foreach (var held in releases)
{
held.TrySetResult(ValidationJson(new { code = 0 }));
}
async Task Cleanup(Func<Task> action)
{
try
{
await action();
}
catch (Exception ex)
{
errors.Add(ex.ToString());
}
}
await Cleanup(Drain);
if (server != null)
{
await Cleanup(() => server.ClearKVForGame());
}
if (context != null)
{
await Cleanup(() => context.CloseAsync());
}
if (user != null)
{
await Cleanup(() => user.CloseKVForValidationAsync());
}
await Cleanup(() =>
{
ValidationContextAccess.Use(originalContainer);
ValidationContextAccess.Events = originalEvents;
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
return Task.CompletedTask;
});
foreach (var error in observed.Errors)
{
if (!expectedErrors.Contains(error))
{
errors.Add(error.ToString());
}
}
restored = errors.Count == 0 && observed.Active == 0 && ReferenceEquals(asap.core.GContext.container, originalContainer) &&
ReferenceEquals(ValidationContextAccess.Events, originalEvents) && ReferenceEquals(System.Threading.SynchronizationContext.Current, originalContext);
if (!restored)
{
failedMatchmakingCleanup = context ?? (object)observed;
}
running = false;
}
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P8D-Matchmaking", assertions,
auth, gets, sends, pfTransport, restored, failure, errors, expectedCallbackErrors = observed.Errors.Count(expectedErrors.Contains),
temporaryContainerIsolation = true, formalRequests = 0, playing = EditorApplication.isPlaying, naturalPanelCovered = false });
}
private static object failedTitleNewsCleanup;
private sealed class NewsRedPoint : IUIRedPoint
{
internal bool Value;
public void SetRedPointState(bool state)
{
Value = state;
}
}
private static async Task<string> RunTitleNews(bool failEarly = false)
{
const string key = "TitleNewsEvent";
const System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic;
var instanceField = typeof(KVMgr).GetField("instance", flags);
var redField = typeof(RedPointManager).GetField("instance", flags);
if (running || failedTitleNewsCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || asap.core.GContext.Ready ||
PlayerKVGameplayLoop.Enabled || instanceField.GetValue(null) != null ||
UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0)
{
throw new InvalidOperationException("Title news validation requires an idle isolated Editor.");
}
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var originalContext = System.Threading.SynchronizationContext.Current;
var originalRed = redField.GetValue(null);
var hadKey = UnityEngine.PlayerPrefs.HasKey(key);
var oldValue = UnityEngine.PlayerPrefs.GetString(key);
running = true;
var observed = new LeaderboardContext(originalContext);
var errors = new List<string>();
var releases = new List<TaskCompletionSource<System.Net.Http.HttpResponseMessage>>();
var holds = new Queue<TaskCompletionSource<System.Net.Http.HttpResponseMessage>>();
PlayerKVLoginContext context = null;
CustomServerMgr server = null;
KVUserService user = null;
Task continuation = null;
TaskCompletionSource<PlayFab.ClientModels.TitleNewsItem> orderedCompletion = null;
string failure = null;
bool restored = false;
bool earlyFailureObserved = false;
bool cleanupCanceled = false;
int assertions = 0, sends = 0, auth = 0, gets = 0, pfTransport = 0;
void Check(bool condition, string detail)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("Title news: " + detail);
}
}
void Publish(TitleNewsEvent evt, bool complete = true)
{
var active = observed.Active;
var started = observed.Started;
var posted = observed.Posted;
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
asap.core.GContext.Publish(evt);
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
}
Check(observed.Started == started + 1, "actual async void entered");
if (complete)
{
Check(observed.Active == active && observed.Posted == posted && observed.Errors.Count == 0,
"actual full consumer completed before inspecting globals");
}
}
try
{
var api = new Uri(PlayerKVRuntimeSelection.FormalApiUrl);
var config = new RetryConfig("101");
config.Set("EventApiURL", api.AbsoluteUri);
var timestamp = new DateTime(2026, 10, 9, 1, 2, 3, DateTimeKind.Utc);
var body = "{\"code\":1,\"news\":[{\"newsId\":\"first\",\"title\":\"title\",\"body\":\"body\",\"timestamp\":\"2026-10-09T01:02:03Z\"},{\"newsId\":\"later\",\"timestamp\":\"2026-10-10T00:00:00Z\"}]}";
var validBody = body;
var status = System.Net.HttpStatusCode.OK;
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-news-cache", Guid.NewGuid().ToString("N")));
context = new PlayerKVLoginContext("101", root, 803, _ => true, api,
() => new game.Account.S101AccountSession(api, cookies => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "account/Login"), "fake login route");
auth++;
cookies.Add(api, new System.Net.Cookie("sid", "synthetic"));
return ValidationJson(new { state = 0, internalId = 101, newCreate = false,
createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
})),
() => new PlayerKVGameSessionBridge(_ => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "playerdata/Get"), "fake KV route");
gets++;
return ValidationJson(new { data = new Dictionary<string, string>() });
})));
Check((await context.PrepareAsync()).Prepared, "real prepared context");
Check(context.TryAcquireAccountLease(PlayerKVControlledLoadCapability.CreateForGame(_ => new ValidationHttp(null, async request =>
{
Check(request.Method == System.Net.Http.HttpMethod.Post && request.RequestUri == new Uri(api, "commondata/GetTitleNews"), "actual published route");
Check(Newtonsoft.Json.Linq.JObject.Parse(await request.Content.ReadAsStringAsync()).Count == 0, "original empty request");
sends++;
if (holds.Count > 0)
{
return await holds.Dequeue().Task;
}
return new System.Net.Http.HttpResponseMessage(status) { Content = new System.Net.Http.StringContent(body) };
})), out var lease), "real lease");
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
server = new CustomServerMgr(config, _ => new ValidationHttp(request =>
{
pfTransport++;
throw new InvalidOperationException("PF transport forbidden");
}));
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
}
server.BindKVForGame(lease);
server.EnableKVBusiness(lease.Epoch);
user = new KVUserService { customServerMgr = server };
void Created(DateTime value)
{
typeof(KVUserService).GetProperty("CreateTime").SetValue(user, value);
}
Created(context.AccountDescriptor.CreateTimeUtc);
var isolated = new asap.core.Container();
ValidationContextAccess.Use(isolated);
ValidationContextAccess.Events = new asap.core.EventAggregator();
asap.core.ContainerExtensions.RegisterInstance<IUserService>(isolated, user);
asap.core.ContainerExtensions.RegisterInstance<ICustomServerMgr>(isolated, server);
var red = new NewsRedPoint();
var redManager = new RedPointManager();
redManager.AddRedPoint(RedPointName.Announcement, red);
redField.SetValue(null, redManager);
var manager = new TileNewsManager();
var oldNews = new PlayFab.ClientModels.TitleNewsItem { NewsId = "old" };
manager.News = oldNews;
UnityEngine.PlayerPrefs.SetString(key, "unread");
var evt = new TitleNewsEvent();
Publish(evt);
Check(ReferenceEquals(evt.titleNewsItem, oldNews), "event retains original old News");
Check(ReferenceEquals(await evt.titleNewsItemAwait.Task, manager.News) && manager.News.NewsId == "first" &&
manager.News.Title == "title" && manager.News.Body == "body" && manager.News.Timestamp == timestamp,
"original first selection and exact returned fields");
Check(red.Value && UnityEngine.PlayerPrefs.GetString(key) == "unread", "unread old account red without marking read");
UnityEngine.PlayerPrefs.SetString(key, timestamp.ToString());
Publish(new TitleNewsEvent());
Check(!red.Value, "original read timestamp comparison");
UnityEngine.PlayerPrefs.SetString(key, "unread");
foreach (var created in new[] { timestamp, timestamp.AddDays(1) })
{
Created(created);
Publish(new TitleNewsEvent());
Check(!red.Value, "equal or newer account does not receive red");
}
Created(context.AccountDescriptor.CreateTimeUtc);
redManager.SetRedPointState(RedPointName.Announcement, true);
var prior = manager.News;
evt = new TitleNewsEvent { show = true };
orderedCompletion = evt.titleNewsItemAwait;
bool atCompletion = false;
continuation = evt.titleNewsItemAwait.Task.ContinueWith(_ =>
{
atCompletion = true;
Check(UnityEngine.PlayerPrefs.GetString(key) == "unread" && red.Value, "TCS completes before Prefs and red changes");
}, System.Threading.CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default);
if (failEarly)
{
throw new InvalidOperationException("Expected P8C validation failure before publication.");
}
Publish(evt);
await continuation;
Check(atCompletion && ReferenceEquals(evt.titleNewsItem, prior) && !red.Value &&
UnityEngine.PlayerPrefs.GetString(key) == timestamp.ToString(), "show marks original string after TCS and clears red");
foreach (var invalid in new[] { "{\"code\":1,\"news\":[]}", "{\"code\":0,\"news\":[]}",
"{\"code\":1,\"news\":null}", "{", "", "{\"code\":1,\"news\":[null]}",
"{\"code\":1,\"news\":[{\"timestamp\":\"bad-time\"}]}" })
{
body = invalid;
manager.News = oldNews;
redManager.SetRedPointState(RedPointName.Announcement, true);
UnityEngine.PlayerPrefs.SetString(key, "unchanged");
evt = new TitleNewsEvent { show = true };
Publish(evt);
Check(ReferenceEquals(evt.titleNewsItem, oldNews) && await evt.titleNewsItemAwait.Task == null && manager.News == null &&
!red.Value && UnityEngine.PlayerPrefs.GetString(key) == "unchanged", "failure/empty follows original clear and no read write");
}
body = validBody;
status = System.Net.HttpStatusCode.InternalServerError;
evt = new TitleNewsEvent { show = true };
Publish(evt);
Check(await evt.titleNewsItemAwait.Task == null && manager.News == null && !red.Value &&
UnityEngine.PlayerPrefs.GetString(key) == "unchanged", "HTTP500 original failure result");
status = System.Net.HttpStatusCode.OK;
var held = new TaskCompletionSource<System.Net.Http.HttpResponseMessage>();
releases.Add(held);
holds.Enqueue(held);
var late = new TitleNewsEvent { show = true };
Publish(late, false);
Check(observed.Active == 1 && !late.titleNewsItemAwait.Task.IsCompleted, "real delayed consumer remains active");
status = System.Net.HttpStatusCode.Unauthorized;
evt = new TitleNewsEvent { show = true };
Publish(evt);
Check(await evt.titleNewsItemAwait.Task == null, "401 failure consumed");
held.SetResult(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new System.Net.Http.StringContent(validBody)
});
await observed.WaitForIdle();
Check(await late.titleNewsItemAwait.Task == null && manager.News == null && !red.Value &&
UnityEngine.PlayerPrefs.GetString(key) == "unchanged", "late 200 after revocation cannot publish news or read marker");
Check(pfTransport == 0 && auth == 1 && gets == 1 && !user.IsAuthorized, "fake transports only, no published game authorization");
}
catch (Exception ex)
{
failure = ex.ToString();
earlyFailureObserved = failEarly && ex is InvalidOperationException &&
ex.Message == "Expected P8C validation failure before publication.";
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
foreach (var held in releases)
{
held.TrySetResult(ValidationJson(new { code = 0 }));
}
async Task Cleanup(Func<Task> action)
{
try
{
await action();
}
catch (Exception ex)
{
errors.Add(ex.ToString());
}
}
await Cleanup(() => observed.WaitForIdle());
if (observed.Active == 0 && orderedCompletion != null && !orderedCompletion.Task.IsCompleted)
{
cleanupCanceled = orderedCompletion.TrySetCanceled();
}
if (continuation != null)
{
await Cleanup(async () =>
{
try
{
await continuation;
}
catch (OperationCanceledException) when (cleanupCanceled && continuation.IsCanceled)
{
// Only our cleanup cancellation is expected; no successful news result is invented.
}
});
}
if (server != null)
{
await Cleanup(() => server.ClearKVForGame());
}
if (context != null)
{
await Cleanup(() => context.CloseAsync());
}
if (user != null)
{
await Cleanup(() => user.CloseKVForValidationAsync());
}
await Cleanup(() =>
{
if (hadKey)
{
UnityEngine.PlayerPrefs.SetString(key, oldValue);
}
else
{
UnityEngine.PlayerPrefs.DeleteKey(key);
}
Check(UnityEngine.PlayerPrefs.HasKey(key) == hadKey && UnityEngine.PlayerPrefs.GetString(key) == oldValue, "actual Prefs restoration");
return Task.CompletedTask;
});
await Cleanup(() =>
{
redField.SetValue(null, originalRed);
return Task.CompletedTask;
});
await Cleanup(() =>
{
ValidationContextAccess.Use(originalContainer);
ValidationContextAccess.Events = originalEvents;
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
return Task.CompletedTask;
});
foreach (var error in observed.Errors)
{
errors.Add(error.ToString());
}
restored = errors.Count == 0 && observed.Active == 0 && ReferenceEquals(redField.GetValue(null), originalRed) &&
ReferenceEquals(asap.core.GContext.container, originalContainer) && ReferenceEquals(ValidationContextAccess.Events, originalEvents) &&
ReferenceEquals(System.Threading.SynchronizationContext.Current, originalContext);
if (!restored)
{
failedTitleNewsCleanup = context ?? (object)observed;
}
running = false;
}
return JsonConvert.SerializeObject(new { success = (failEarly ? earlyFailureObserved && cleanupCanceled : failure == null) && restored,
caseId = failEarly ? "P8C-TitleNews-Cleanup" : "P8C-TitleNews", assertions, earlyFailureObserved, cleanupCanceled,
auth, gets, sends, pfTransport, restored, failure, errors, temporaryPrefsKey = key,
temporaryContainerIsolation = true, formalRequests = 0, playing = EditorApplication.isPlaying });
}
private static object failedLeaderboardCleanup;
private static async Task<string> RunLeaderboard()
{
var instanceField = typeof(KVMgr).GetField("instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
if (running || failedLeaderboardCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || asap.core.GContext.Ready ||
PlayerKVGameplayLoop.Enabled || instanceField.GetValue(null) != null ||
UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0)
{
throw new InvalidOperationException("Leaderboard validation requires an idle isolated Editor.");
}
running = true;
var previousContext = System.Threading.SynchronizationContext.Current;
var observed = new LeaderboardContext(previousContext);
PlayerKVLoginContext context = null;
CustomServerMgr server = null;
KVUserService user = null;
IDisposable subscription = null;
Task<PlayFab.ClientModels.GetLeaderboardResult> pending = null;
TaskCompletionSource<System.Net.Http.HttpResponseMessage> held = null;
var errors = new List<string>();
string failure = null;
int assertions = 0, sends = 0, pfTransport = 0, events = 0, logins = 0, gets = 0;
bool restored = false;
void Check(bool condition, string detail)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("Leaderboard: " + detail);
}
}
try
{
var api = new Uri(PlayerKVRuntimeSelection.FormalApiUrl);
var config = new RetryConfig("101");
config.Set("EventApiURL", api.AbsoluteUri);
var status = System.Net.HttpStatusCode.OK;
var body = "{\"code\":1,\"leaderboard\":[{\"playFabId\":\"102\",\"position\":4,\"statValue\":500002,\"profile\":{\"displayName\":null,\"avatarUrl\":\"avatar102\",\"lastLogin\":\"2026-10-09T01:02:03Z\"}},{\"playFabId\":\"101\",\"position\":2,\"statValue\":500002,\"profile\":{\"displayName\":\"first\",\"avatarUrl\":null,\"lastLogin\":null}}]}";
var validBody = body;
Newtonsoft.Json.Linq.JObject sent = null;
var delayNext = false;
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-leaderboard-cache", Guid.NewGuid().ToString("N")));
context = new PlayerKVLoginContext("101", root, 801, _ => true, api,
() => new game.Account.S101AccountSession(api, cookies => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "account/Login"), "fake login route");
logins++;
cookies.Add(api, new System.Net.Cookie("sid", "synthetic"));
return ValidationJson(new { state = 0, internalId = 101, newCreate = false,
createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
})),
() => new PlayerKVGameSessionBridge(_ => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "playerdata/Get"), "fake KV route");
gets++;
return ValidationJson(new { data = new Dictionary<string, string>() });
})));
Check((await context.PrepareAsync()).Prepared, "real prepared context");
Check(context.TryAcquireAccountLease(PlayerKVControlledLoadCapability.CreateForGame(_ => new ValidationHttp(null, async request =>
{
Check(request.Method == System.Net.Http.HttpMethod.Post && request.RequestUri == new Uri(api, "leaderboard/GetLeaderboard"), "real route and method");
sends++;
sent = Newtonsoft.Json.Linq.JObject.Parse(await request.Content.ReadAsStringAsync());
if (delayNext)
{
delayNext = false;
return await held.Task;
}
return new System.Net.Http.HttpResponseMessage(status) { Content = new System.Net.Http.StringContent(body) };
})), out var lease), "real account lease");
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
server = new CustomServerMgr(config, _ => new ValidationHttp(request =>
{
pfTransport++;
throw new InvalidOperationException("PF transport forbidden");
}));
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(previousContext);
}
server.BindKVForGame(lease);
server.EnableKVBusiness(lease.Epoch);
user = new KVUserService { customServerMgr = server };
var board = new GameCore.LeadboardData { userService = user, customServerMgr = server };
var result = await board.GetLeadboardData("LevelB");
Check(result?.Leaderboard.Count == 2 && result.Leaderboard[0].PlayFabId == "102", "real UserID mapping");
Check((string)sent["statisticName"] == "LevelB" && (int)sent["maxResultsCount"] == 50 &&
(int)sent["startPosition"] == 0 && sent.Count == 3, "original default request");
Check(result.Leaderboard[0].Profile.LastLogin == new DateTime(2026, 10, 9, 1, 2, 3, DateTimeKind.Utc) &&
result.Leaderboard[1].Profile.LastLogin == null, "real DateTime and null");
await board.GetLeadboardData("EULevelB", 17);
Check((string)sent["statisticName"] == "EULevelB" && (int)sent["maxResultsCount"] == 17, "original region/count");
subscription = asap.core.GContext.OnEvent<GameCore.PFRankDataEvent>().Subscribe(evt =>
{
events++;
Check(!evt.isLocal && board.LeadboardDataList.Count == 2 && board.LeadboardDataList[0].playFabId == "102", "event follows real list publication");
});
void Consume()
{
var started = observed.Started;
var posted = observed.Posted;
var previous = System.Threading.SynchronizationContext.Current;
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
board.GetLevelLeadboardData();
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(previous);
}
Check(observed.Started == started + 1 && observed.Active == 0 && observed.Posted == posted,
"real async void operation completed synchronously without pending continuation");
}
Consume();
var originalList = board.LeadboardDataList;
Check(events == 1 && originalList[0].position == 4 && originalList[0].rank == 5 && originalList[0].value == 500002 &&
originalList[1].playFabId == "101" && originalList[1].position == 2, "original order and Position+1 without reranking");
Check(originalList[0].displayName == user.GetDefaultName("102") && originalList[0].avatarUrl == "avatar102" &&
originalList[0].LastLogin == result.Leaderboard[0].Profile.LastLogin, "real item/default name/time mapping");
Check(user.GetPlayInfo("102").name == originalList[0].displayName && user.GetPlayInfo("101").name == "first", "original profile cache consumer");
foreach (var invalid in new[] { "{\"code\":1,\"leaderboard\":[]}", "", "null", "{", "[]", "{}",
"{\"code\":0,\"leaderboard\":[]}", "{\"code\":1,\"leaderboard\":null}",
"{\"code\":1,\"leaderboard\":[null]}", "{\"code\":1,\"leaderboard\":[{\"profile\":null}]}",
"{\"code\":1,\"leaderboard\":[{\"profile\":{\"lastLogin\":\"bad-time\"}}]}" })
{
body = invalid;
var empty = invalid == "{\"code\":1,\"leaderboard\":[]}";
result = await board.GetLeadboardData("LevelB");
Check(empty ? result?.Leaderboard.Count == 0 : result == null, "empty success differs from failure");
Consume();
Check(ReferenceEquals(originalList, board.LeadboardDataList) && events == 1, "empty/failure retains old list without event after real completion");
}
body = validBody;
status = System.Net.HttpStatusCode.InternalServerError;
Check(await board.GetLeadboardData("LevelB") == null, "real HTTP500 remains failure");
Consume();
Check(ReferenceEquals(originalList, board.LeadboardDataList) && events == 1, "HTTP500 preserves original list");
status = System.Net.HttpStatusCode.OK;
held = new TaskCompletionSource<System.Net.Http.HttpResponseMessage>();
delayNext = true;
pending = board.GetLeadboardData("LevelB");
await RetryWait(() => !delayNext);
Check(!pending.IsCompleted, "real delayed response pending");
status = System.Net.HttpStatusCode.Unauthorized;
Check(await board.GetLeadboardData("LevelB") == null, "401 is a failure");
held.SetResult(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) { Content = new System.Net.Http.StringContent(validBody) });
Check(await pending == null, "late old-owner success discarded");
var sendsBefore = sends;
var rejected = false;
try
{
await board.GetLeadboardData("LevelB");
}
catch (InvalidOperationException)
{
rejected = true;
}
Check(rejected && sendsBefore == sends, "revoked owner cannot send");
Check(pfTransport == 0 && logins == 1 && gets == 1 && observed.Active == 0, "no PF transport/relogin or pending async void");
}
catch (Exception ex)
{
failure = ex.ToString();
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(previousContext);
held?.TrySetResult(ValidationJson(new { }));
async Task Cleanup(Func<Task> action)
{
try
{
await action();
}
catch (Exception ex)
{
errors.Add(ex.ToString());
}
}
if (pending != null)
{
await Cleanup(async () =>
{
await pending;
});
}
await Cleanup(() => observed.WaitForIdle());
await Cleanup(() =>
{
subscription?.Dispose();
return Task.CompletedTask;
});
if (server != null)
{
await Cleanup(() => server.ClearKVForGame());
}
if (context != null)
{
await Cleanup(() => context.CloseAsync());
}
if (user != null)
{
await Cleanup(() => user.CloseKVForValidationAsync());
}
foreach (var error in observed.Errors)
{
errors.Add(error.ToString());
}
restored = errors.Count == 0 && observed.Active == 0 && ReferenceEquals(System.Threading.SynchronizationContext.Current, previousContext);
if (!restored)
{
failedLeaderboardCleanup = context ?? (object)observed;
}
running = false;
}
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P8A-Leaderboard", assertions,
sends, logins, gets, pfTransport, events, restored, failure, errors, formalRequests = 0,
playing = EditorApplication.isPlaying, globalContainerChanged = false });
}
private static object failedFriendCleanup;
private sealed class StartupMailHandler : BaseMailHandler
{
internal int Fetches
{
get;
private set;
}
internal StartupMailHandler(MailCache cache, ICustomServerMgr server) : base(cache, server)
{
}
public override Task<bool> FetchMail()
{
Fetches++;
return Task.FromResult(true);
}
}
private static async Task<string> RunFriends(bool verifyStartup = false)
{
#if AGG
const bool realChannelCounters = true;
#else
const bool realChannelCounters = false;
#endif
var instanceField = typeof(KVMgr).GetField("instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
if (realChannelCounters || running || failedFriendCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || asap.core.GContext.Ready ||
PlayerKVGameplayLoop.Enabled || instanceField.GetValue(null) != null ||
UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0)
{
throw new InvalidOperationException("Friends validation requires idle isolated Editor without live channel counters.");
}
running = true;
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var originalContext = System.Threading.SynchronizationContext.Current;
var observed = new LeaderboardContext(originalContext);
var isolated = new asap.core.Container();
CustomServerMgr server = null;
PlayerKVGameLoadCoordinator coordinator = null;
KVUserService user = null;
IDisposable listSubscription = null, profileSubscription = null;
var releases = new List<TaskCompletionSource<System.Net.Http.HttpResponseMessage>>();
var holds = new Queue<TaskCompletionSource<System.Net.Http.HttpResponseMessage>>();
Task<(string, int)> pendingLevel = null;
InGameMailService startupMail = null;
SignalRService startupRT = null;
DevIAPService startupIAP = null;
StartupMailHandler startupHandler = null;
UnityEngine.Application.LogCallback startupLog = null;
var startupPrefs = new Dictionary<string, (bool Exists, string Value)>();
int orderCallbacks = 0;
var errors = new List<string>();
string failure = null;
bool restored = false;
int assertions = 0, sends = 0, auth = 0, gets = 0, pfTransport = 0, listEvents = 0, profileEvents = 0;
void Check(bool condition, string detail)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("Friends: " + detail);
}
}
void Invoke(Action action, bool complete = true)
{
var started = observed.Started;
var posted = observed.Posted;
var previous = System.Threading.SynchronizationContext.Current;
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
action();
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(previous);
}
if (complete)
{
Check(observed.Started == started + 1 && observed.Active == 0 && observed.Posted == posted && observed.Errors.Count == 0,
"original async void truly completed synchronously");
}
}
async Task LevelFails(string id)
{
var failed = false;
try
{
await user.GetPlayLv(id);
}
catch (InvalidOperationException)
{
failed = true;
}
Check(failed, "ordinary level remains a failed Task");
}
try
{
var api = new Uri(PlayerKVRuntimeSelection.FormalApiUrl);
var config = new RetryConfig("101");
config.Set("EventApiURL", api.AbsoluteUri);
var profileBody = "{\"code\":1,\"info\":{\"displayName\":\"legacy\",\"avatarUrl\":\"legacy\",\"level\":999},\"kvProfile\":{\"displayName\":\"KV name\",\"avatarUrl\":\"KV avatar\",\"level\":37}}";
var friendBody = "{\"code\":1,\"friends\":[]}";
var status = System.Net.HttpStatusCode.OK;
Newtonsoft.Json.Linq.JObject sent = null;
System.Threading.SynchronizationContext.SetSynchronizationContext(observed);
try
{
server = new CustomServerMgr(config, _ => new ValidationHttp(request =>
{
pfTransport++;
throw new InvalidOperationException("PF transport forbidden");
}));
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
}
user = new KVUserService { customServerMgr = server };
long boundEpoch = 0;
coordinator = new PlayerKVGameLoadCoordinator(() => true, lease =>
{
server.BindKVForGame(lease);
boundEpoch = lease.Epoch;
}, server.ClearKVForGame);
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-friends-cache", Guid.NewGuid().ToString("N")));
var capability = PlayerKVGameLoadCapability.CreateForGame(api, root,
cookies => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "account/Login"), "fake login route");
auth++;
cookies.Add(api, new System.Net.Cookie("sid", "synthetic"));
return ValidationJson(new { state = 0, internalId = 101, newCreate = false,
createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
}),
_ => new ValidationHttp(request =>
{
Check(request.RequestUri == new Uri(api, "playerdata/Get"), "fake own archive read");
gets++;
return ValidationJson(new { data = new Dictionary<string, string> { ["Fixture"] = "1" } });
}),
_ => new ValidationHttp(null, async request =>
{
Check(request.Method == System.Net.Http.HttpMethod.Post && request.RequestUri.GetLeftPart(UriPartial.Authority) == "http://s101.local:18080", "fixed authenticated POST");
var route = request.RequestUri.AbsolutePath;
Check(route == "/friend/GetFriendsList" || route == "/friend/SearchFriend", "only published friend routes");
sends++;
sent = Newtonsoft.Json.Linq.JObject.Parse(await request.Content.ReadAsStringAsync());
Check(route.EndsWith("SearchFriend") ? sent.Count == 1 && sent["PlayFabId"] != null : sent.Count == 0,
"old identity field or empty list request, no target KV shortcut");
if (holds.Count != 0)
{
return await holds.Dequeue().Task;
}
return new System.Net.Http.HttpResponseMessage(status)
{
Content = new System.Net.Http.StringContent(route.EndsWith("SearchFriend") ? profileBody : friendBody)
};
}));
var prepared = await coordinator.LoadForGameAsync("101", capability, user.LoginLifetime);
Check(prepared.State == PlayerKVGameLoadState.PreparedForGame && coordinator.TryGetCurrentGameHandle(prepared.Epoch, out _), "actual coordinator prepared original handle");
coordinator.TryGetCurrentGameHandle(prepared.Epoch, out var handle);
SetUserField(user, "coordinator", coordinator);
SetUserField(user, "handle", handle);
SetUserField(user, "epoch", prepared.Epoch);
SetUserField(user, "playerId", "101");
server.EnableKVBusiness(boundEpoch);
Check(user.UserId == "101" && !user.IsAuthorized, "real handoff identity, not published gameplay authorization");
ValidationContextAccess.Use(isolated);
ValidationContextAccess.Events = new asap.core.EventAggregator();
asap.core.ContainerExtensions.RegisterInstance<IUserService>(isolated, user);
profileSubscription = asap.core.GContext.OnEvent<GetClubPlayInfoEvent>().Subscribe(_ => profileEvents++);
listSubscription = asap.core.GContext.OnEvent<SocialFriendListChangedData>().Subscribe(_ => listEvents++);
if (verifyStartup)
{
const System.Reflection.BindingFlags fields = System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic;
foreach (var key in new[] { "mail_cache__101", "mail_sync_Time_101" })
{
startupPrefs[key] = (UnityEngine.PlayerPrefs.HasKey(key), UnityEngine.PlayerPrefs.GetString(key));
}
var directory = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath, "../../cfgData"));
var tables = new cfg.Tables(name => SimpleJSON.JSON.Parse(System.IO.File.ReadAllText(System.IO.Path.Combine(directory, name + ".json"))));
Check(tables.TbAutoDeliveryMail.DataList.Count > 0, "original mail Min input is populated");
startupRT = new SignalRService(server, config);
asap.core.ContainerExtensions.RegisterInstance<IRTService>(isolated, startupRT);
Check(!startupRT.IsConnected && await startupRT.Publish("Test", "synthetic") == null &&
await startupRT.Publish("Test", "synthetic", "synthetic") == null, "unconnected publish cannot send");
startupMail = new InGameMailService(server, tables);
var cache = (MailCache)typeof(InGameMailService).GetField("_mailCache", fields).GetValue(startupMail);
startupHandler = new StartupMailHandler(cache, server);
typeof(InGameMailService).GetField("_handler", fields).SetValue(startupMail, startupHandler);
var cacheUser = typeof(MailCache).GetField("_userId", fields);
var handlers = (Dictionary<string, Action<string>>)typeof(SignalRService).GetField("handlers", fields).GetValue(startupRT);
startupMail.Init();
Check((string)cacheUser.GetValue(cache) == "101" && startupHandler.Fetches == 0, "original identity cache and deferred mail branch");
asap.core.GContext.Publish(new EvtAPISvrLoginSuccess());
Check(startupHandler.Fetches == 1, "original login subscription calls Fetch boundary");
Invoke(() => handlers[nameof(FetchMailEvt)]("{}"));
await P6AWait(observed.WaitForIdle());
Check(startupHandler.Fetches == 2, "original RT subscription calls Fetch boundary");
startupMail.Reset();
Check(cacheUser.GetValue(cache) == null, "original Reset unloads mail cache");
asap.core.GContext.Publish(new EvtAPISvrLoginSuccess());
handlers[nameof(FetchMailEvt)]("{}");
Check(startupHandler.Fetches == 2 && observed.Active == 0, "Reset removes both subscriptions");
startupMail.Init();
asap.core.GContext.Publish(new EvtAPISvrLoginSuccess());
Invoke(() => handlers[nameof(FetchMailEvt)]("{}"));
await P6AWait(observed.WaitForIdle());
Check(startupHandler.Fetches == 4 && (string)cacheUser.GetValue(cache) == "101", "Init after Reset has one subscription each");
startupMail.Reset();
asap.core.GContext.Publish(new EvtAPISvrLoginSuccess());
handlers[nameof(FetchMailEvt)]("{}");
Check(startupHandler.Fetches == 4, "second Reset removes subscribers");
startupLog = (message, stack, type) =>
{
if (message.StartsWith("[AggIAPService] OnOrderCompleted", StringComparison.Ordinal))
{
orderCallbacks++;
}
};
UnityEngine.Application.logMessageReceived += startupLog;
startupIAP = new DevIAPService { rts = startupRT };
startupIAP.Init();
handlers[nameof(SC_OrderConfirmEvt)]("{}");
Check(orderCallbacks == 1, "original Dev order subscription entered once");
startupIAP.Init();
handlers[nameof(SC_OrderConfirmEvt)]("{}");
Check(orderCallbacks == 2, "original Init releases previous order subscription");
startupIAP.Release();
handlers[nameof(SC_OrderConfirmEvt)]("{}");
Check(orderCallbacks == 2, "original Release removes order subscription");
var loginField = typeof(SignalRService).GetField("loginSubscription", fields);
startupRT.WaitForAPISvrLogin();
var loginSubscription = loginField.GetValue(startupRT);
startupRT.WaitForAPISvrLogin();
Check(loginSubscription != null && ReferenceEquals(loginSubscription, loginField.GetValue(startupRT)), "RT does not subscribe twice");
await startupRT.ReleaseAsync();
await startupRT.ReleaseAsync();
var sessionChanged = (Delegate)typeof(CustomServerMgr).GetField("SessionChanged", fields).GetValue(server);
Check(loginField.GetValue(startupRT) == null && handlers.Count == 0 && !startupRT.IsConnected &&
(sessionChanged == null || sessionChanged.GetInvocationList().All(item => !ReferenceEquals(item.Target, startupRT))), "RT release clears registrations");
var rejected = false;
try
{
startupRT.OnEvent<FetchMailEvt>(_ =>
{
});
}
catch (ObjectDisposedException)
{
rejected = true;
}
Check(rejected, "released RT rejects new subscription");
Check(auth == 1 && gets == 1 && sends == 0 && pfTransport == 0 && observed.Active == 0 && observed.Errors.Count == 0, "only synthetic account preparation, no business transport");
}
else
{
var profileCache = UserField<Dictionary<string, PlayInfo>>(user, "profiles");
var levelCache = UserField<Dictionary<string, int>>(user, "levels");
var cacheEvents = profileEvents;
var cacheSends = sends;
var nullRejected = false;
try
{
user.SetPlayInfo(null, "Explicit name", "avatar");
}
catch (ArgumentNullException)
{
nullRejected = true;
}
Check(nullRejected, "explicit null cache key keeps original dictionary failure");
user.SetPlayInfo("", "Empty key", "empty-avatar");
Check(profileCache.TryGetValue("", out var emptyProfile) && emptyProfile.name == "Empty key" &&
emptyProfile.avatarUrl == "empty-avatar" && user.GetPlayInfo("") == null, "empty key write and empty lookup keep distinct original contracts");
user.SetPlayInfo("101", "Before", "before-avatar");
var oldProfile = user.GetPlayInfo("101");
user.SetPlayInfo("101", "After", "after-avatar");
Check(!ReferenceEquals(oldProfile, user.GetPlayInfo("101")) && oldProfile.name == "Before" &&
user.GetPlayInfo("101").avatarUrl == "after-avatar", "explicit cache assignment replaces only the dictionary object");
user.SetPlayInfo("101", "", null);
Check(user.GetPlayInfo("101").name == "Angler#101", "approved short UserID default name remains");
user.SetPlayerLv("109", 7);
user.ClearPlayInfos();
Check(profileCache.Count == 0 && levelCache.Count == 0 && profileEvents == cacheEvents && sends == cacheSends,
"pure cache writes and clear add no event or transport");
Check((await user.GetPlayLv("109")).Item2 == 37 && (string)sent["PlayFabId"] == "109", "ordinary remote level uses kvProfile rather than legacy info");
var before = sends;
Check((await user.GetPlayLv("109")).Item2 == 37 && user.GetPlayerLv("109") == 37 && sends == before, "successful level uses original cache");
user.SetPlayerLv("109", -3);
await LevelFails("109");
await LevelFails(null);
await LevelFails("");
await LevelFails("101");
Check(sends == before && user.GetPlayerLv("109") == -3, "negative cache/null/empty/unpublished self do not query");
foreach (var sample in new[]
{
(Body: "{\"code\":1,\"kvProfile\":{}}", Level: (int?)1),
(Body: "{\"code\":1,\"kvProfile\":{\"level\":0}}", Level: (int?)0),
(Body: "{\"code\":1,\"kvProfile\":{\"level\":-5}}", Level: (int?)null),
(Body: "{\"code\":1,\"info\":{\"level\":99},\"kvProfile\":null}", Level: (int?)null),
(Body: "{\"code\":0,\"kvProfile\":{\"level\":99}}", Level: (int?)null),
(Body: "{\"code\":1,\"kvProfile\":{\"level\":\"bad\"}}", Level: (int?)null),
(Body: "{", Level: (int?)null),
(Body: "", Level: (int?)null)
})
{
user.ClearPlayInfos();
profileBody = sample.Body;
before = sends;
Check(user.GetPlayerLv("109") == 1 && sends == before, "synchronous display default does not query");
if (sample.Level.HasValue)
{
Check((await user.GetPlayLv("109")).Item2 == sample.Level.Value, "entity-present missing-level default or actual level");
}
else
{
await LevelFails("109");
Check(user.GetPlayerLv("109") == 1, "failed level did not fill cache");
}
Check(sends == before + 1, "one query without retry");
}
foreach (var sample in new[]
{
(Body: "{\"code\":1,\"info\":{\"displayName\":\"legacy\",\"avatarUrl\":\"legacy\"},\"kvProfile\":{\"displayName\":\"KV name\",\"avatarUrl\":\"KV avatar\",\"level\":37}}", Success: true),
(Body: "{\"code\":1,\"kvProfile\":{\"displayName\":\"\",\"avatarUrl\":null}}", Success: true),
(Body: "{\"code\":1,\"info\":{\"displayName\":\"legacy\"},\"kvProfile\":null}", Success: false),
(Body: "{invalid", Success: false),
(Body: "", Success: false)
})
{
user.ClearPlayInfos();
profileBody = sample.Body;
before = profileEvents;
PlayInfo profile = null;
Invoke(() => profile = user.GetPlayInfo("110"));
Check(profileEvents == before + (sample.Success ? 1 : 0) && ReferenceEquals(profile, user.GetPlayInfo("110")), "root profile success/failure and original object identity");
Check(profile.name == (sample.Body.Contains("KV name") ? "KV name" : "Angler#110"), "KV name or original placeholder, never legacy fallback");
Check(user.GetPlayerLv("110") == 1, "profile fill never populates levels");
}
string Item(string id, object profile) => JsonConvert.SerializeObject(new { PlayFabId = id, DisplayName = "legacy", Level = 999, Profile = profile });
object Profile(string name, object stats, string last = null) => new { DisplayName = name, AvatarUrl = "avatar", Statistics = stats, LastLogin = last };
var low = new object[] { null, new { Name = "Else", Value = 9999999 }, new { Name = "LevelB", Value = 900001 } };
friendBody = JsonConvert.SerializeObject(new { code = 1, friends = new[]
{
Item("101", Profile("self", low)),
Item("102", Profile(null, low, "2026-10-09T01:02:03Z")),
Item("103", Profile("high", new[] { new { Name = "LevelB", Value = 1900001 } })),
Item("104", null),
Item("105", Profile("null stats", null)),
Item("106", Profile("empty stats", Array.Empty<object>())),
Item("107", Profile("missing LevelB", new[] { new { Name = "Else", Value = 6 } })),
Item("108", Profile("negative", new[] { new { Name = "LevelB", Value = -5 } }))
}});
var friends = new FriendService { userService = user, customServerMgr = server };
Invoke(friends.GetFriendList);
Check(friends.FriendList.Count == 5 && friends.FriendList[0].playFabId == "103" && friends.FriendList[1].playFabId == "102" &&
friends.FriendList[4].value == -5, "original self/profile/stat filtering and LevelB sort");
Check(friends.FriendList.Select((item, index) => item.position == index && item.rank == index + 1).All(value => value) &&
!friends.IsFriendListRefreshing && listEvents == 1, "real list ranks/refresh/event");
Check(friends.FriendList[1].displayName == "Angler#102" && friends.FriendList[1].LastLogin == new DateTime(2026, 10, 9, 1, 2, 3, DateTimeKind.Utc) &&
friends.FriendList[0].LastLogin == null && user.GetPlayInfo("102").name == "Angler#102", "real item time/default name/profile cache");
var oldList = friends.FriendList;
foreach (var invalid in new[] { "", "null", "{", "{\"code\":0,\"friends\":[]}", "{\"code\":1,\"friends\":null}",
"{\"code\":1,\"friends\":[null]}", "{\"code\":1,\"friends\":[\"\"]}",
JsonConvert.SerializeObject(new { code = 1, friends = new[] { Item("102", Profile("bad", low, "bad-time")) } }) })
{
friendBody = invalid;
Invoke(friends.GetFriendList);
Check(ReferenceEquals(oldList, friends.FriendList) && listEvents == 1, "bad payload retains original list after actual completion");
}
friendBody = "{\"code\":1,\"friends\":[]}";
status = System.Net.HttpStatusCode.InternalServerError;
Invoke(friends.GetFriendList);
Check(ReferenceEquals(oldList, friends.FriendList) && listEvents == 1, "real HTTP500 preserves list");
user.ClearPlayInfos();
await LevelFails("109");
Check(user.GetPlayerLv("109") == 1, "real level HTTP500 does not fake default success");
status = System.Net.HttpStatusCode.OK;
Invoke(friends.GetFriendList);
Check(friends.FriendList.Count == 0 && !ReferenceEquals(oldList, friends.FriendList) && listEvents == 2, "successful empty clears list and publishes unlike leaderboard");
profileBody = "{\"code\":1,\"kvProfile\":{\"displayName\":\"late\",\"level\":37}}";
for (var i = 0; i < 2; i++)
{
var release = new TaskCompletionSource<System.Net.Http.HttpResponseMessage>();
releases.Add(release);
holds.Enqueue(release);
}
PlayInfo delayedProfile = null;
before = profileEvents;
Invoke(() => delayedProfile = user.GetPlayInfo("1099"), false);
Invoke(() => pendingLevel = user.GetPlayLv("1098"), false);
Check(holds.Count == 0 && observed.Active == 1 && !pendingLevel.IsCompleted, "real profile and level operations held on fixed owner");
status = System.Net.HttpStatusCode.Unauthorized;
await LevelFails("1097");
foreach (var release in releases)
{
release.SetResult(new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) { Content = new System.Net.Http.StringContent(profileBody) });
}
var levelRejected = false;
try
{
await pendingLevel;
}
catch (InvalidOperationException)
{
levelRejected = true;
}
await P6AWait(observed.WaitForIdle());
Check(levelRejected && delayedProfile.name == "Angler#1099" && profileEvents == before && user.GetPlayerLv("1098") == 1,
"late old-owner responses cannot fill caches or publish");
Check(auth == 1 && gets == 1 && pfTransport == 0 && observed.Errors.Count == 0, "no relogin/PF transport/unobserved async error");
}
}
catch (Exception ex)
{
failure = verifyStartup ? ex.GetType().Name : ex.ToString();
}
finally
{
foreach (var release in releases)
{
release.TrySetResult(ValidationJson(new { }));
}
async Task Cleanup(Func<Task> action)
{
try
{
await action();
}
catch (Exception ex)
{
errors.Add(verifyStartup ? ex.GetType().Name : ex.ToString());
}
}
if (verifyStartup)
{
await Cleanup(() =>
{
startupMail?.Reset();
return Task.CompletedTask;
});
await Cleanup(() =>
{
startupIAP?.Release();
return Task.CompletedTask;
});
await Cleanup(() => startupRT?.ReleaseAsync() ?? Task.CompletedTask);
await Cleanup(() =>
{
if (startupLog != null)
{
UnityEngine.Application.logMessageReceived -= startupLog;
}
return Task.CompletedTask;
});
await Cleanup(() =>
{
foreach (var pair in startupPrefs)
{
Check(UnityEngine.PlayerPrefs.HasKey(pair.Key) == pair.Value.Exists &&
UnityEngine.PlayerPrefs.GetString(pair.Key) == pair.Value.Value, "original mail Prefs untouched");
}
return Task.CompletedTask;
});
}
if (pendingLevel != null)
{
await Cleanup(async () =>
{
try
{
await pendingLevel;
}
catch (InvalidOperationException)
{
// Rejection is expected after revocation and asserted by the scenario.
}
});
}
await Cleanup(() => observed.WaitForIdle());
await Cleanup(() =>
{
listSubscription?.Dispose();
return Task.CompletedTask;
});
await Cleanup(() =>
{
profileSubscription?.Dispose();
return Task.CompletedTask;
});
if (server != null)
{
await Cleanup(() => server.ClearKVForGame());
}
if (coordinator != null)
{
await Cleanup(() => coordinator.Revoke());
}
if (user != null)
{
await Cleanup(() => user.CloseKVForValidationAsync());
}
await Cleanup(() =>
{
ValidationContextAccess.Use(originalContainer);
ValidationContextAccess.Events = originalEvents;
System.Threading.SynchronizationContext.SetSynchronizationContext(originalContext);
return Task.CompletedTask;
});
foreach (var error in observed.Errors)
{
errors.Add(error.ToString());
}
restored = errors.Count == 0 && observed.Active == 0 && ReferenceEquals(asap.core.GContext.container, originalContainer) &&
ReferenceEquals(ValidationContextAccess.Events, originalEvents) && ReferenceEquals(System.Threading.SynchronizationContext.Current, originalContext);
if (!restored)
{
failedFriendCleanup = coordinator ?? (object)observed;
}
running = false;
}
if (verifyStartup)
{
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P12C-StartupSubscriptions", assertions,
auth, gets, sends, pfTransport, restored, failure, errors, fetchBoundaryCalls = startupHandler?.Fetches ?? 0, orderCallbacks,
formalRequests = 0, actualSubscriptionMethods = true, mailFetchStubbed = true, hubConnected = false, naturalUIVerified = false });
}
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P8B-Friends", assertions,
auth, gets, sends, pfTransport, listEvents, profileEvents, restored, failure, errors,
temporaryContainerIsolation = true, publishedGameAuthorization = false, formalRequests = 0, playing = EditorApplication.isPlaying });
}
private static async Task<string> RunOrdinarySave(bool failEarly = false, bool verifyCadence = false)
{
const System.Reflection.BindingFlags fields = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance;
var instanceField = typeof(KVMgr).GetField("instance", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
if (running || EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling ||
EditorApplication.isUpdating || asap.core.GContext.Ready || PlayerKVGameplayLoop.Enabled ||
instanceField.GetValue(null) != null || UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0)
{
throw new InvalidOperationException("Ordinary save validation requires an idle isolated Editor.");
}
running = true;
var bridge = default(PlayerKVGameSessionBridge);
var session = default(game.Account.S101AccountSession);
var shell = default(UnityEngine.GameObject);
var store = default(KVPlayerSaveStore);
var release = new TaskCompletionSource<bool>();
var entered = new TaskCompletionSource<bool>();
var remote = new Dictionary<string, string>();
var bodies = new List<Dictionary<string, string>>();
var receipts = new List<PlayerKVSyncTicket>();
var cadenceGate = new object();
var requestTimes = new List<long>();
var cadenceSamples = new List<object>();
string cadenceFile = null;
int assertions = 0;
string failure = null;
bool restored = false;
double intervalSeconds = 0;
var cleanupErrors = new List<string>();
var loopContext = new P6BLoopContext(System.Threading.SynchronizationContext.Current);
bool earlyFailureObserved = false;
var timer = System.Diagnostics.Stopwatch.StartNew();
void Check(bool condition, string detail)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("Ordinary save: " + detail);
}
}
void Call(KVMgr manager, string name, params object[] args)
{
var previous = System.Threading.SynchronizationContext.Current;
System.Threading.SynchronizationContext.SetSynchronizationContext(loopContext);
try
{
typeof(KVMgr).GetMethod(name, fields).Invoke(manager, args);
}
finally
{
System.Threading.SynchronizationContext.SetSynchronizationContext(previous);
}
}
try
{
// The user can be constructed before the root component or before any store is available.
var early = new KVUserService();
typeof(KVUserService).GetMethod("OnApplicationQuitting", fields).Invoke(early, null);
Check(early.LoginLifetime.IsCancellationRequested, "early user still logs out without a component/store");
var api = new Uri("http://synthetic.invalid/");
session = new game.Account.S101AccountSession(api, jar => new ValidationHttp(_ =>
{
jar.Add(api, new System.Net.Cookie("sid", "ordinary"));
return ValidationJson(new { state = 0, internalId = 17, newCreate = false,
createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
}));
Check((await session.LoginAsync("101")).Success, "synthetic login");
bridge = new PlayerKVGameSessionBridge(_ => new ValidationHttp(null, async request =>
{
if (request.RequestUri.AbsolutePath.EndsWith("/Get", StringComparison.Ordinal))
{
return ValidationJson(new { data = remote });
}
var requestTime = verifyCadence ? System.Diagnostics.Stopwatch.GetTimestamp() : 0;
var body = Newtonsoft.Json.Linq.JObject.Parse(await request.Content.ReadAsStringAsync())["data"].ToObject<Dictionary<string, string>>();
if (verifyCadence)
{
lock (cadenceGate)
{
bodies.Add(body);
requestTimes.Add(requestTime);
}
}
else
{
bodies.Add(body);
}
if (!verifyCadence && bodies.Count == 1)
{
entered.TrySetResult(true);
await release.Task;
}
foreach (var pair in body)
{
remote[pair.Key] = pair.Value;
}
return ValidationJson(new { });
}));
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath,
"../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-ordinary-cache", Guid.NewGuid().ToString("N")));
var opened = await bridge.OpenAsync(session, root, "101", api, 1, _ => true, default);
Check(opened.Success, "original handle");
store = new KVPlayerSaveStore();
store.Bind(opened.Handle, default);
shell = new UnityEngine.GameObject("P6B ordinary lifecycle fixture");
shell.SetActive(false);
shell.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
var manager = shell.AddComponent<KVMgr>();
var phaseTimestamp = verifyCadence ? System.Diagnostics.Stopwatch.GetTimestamp() : 0;
Call(manager, "Awake"); // Fixed callback in idle Editor, not a claim of Play Mode frames.
if (failEarly)
{
throw new InvalidOperationException("P6B expected early fixture failure");
}
var loop = typeof(KVMgr).GetField("tokenSource", fields).GetValue(manager);
Check(bodies.Count == 0, "unbound first tick has no send");
KVMgr.Bind(store);
Check(ReferenceEquals(loop, typeof(KVMgr).GetField("tokenSource", fields).GetValue(manager)) && bodies.Count == 0,
"bind does not restart phase or send");
if (verifyCadence)
{
var owner = (PlayerKVSessionOwner)typeof(PlayerKVGameSessionHandle).GetProperty("Owner", fields).GetValue(opened.Handle);
var state = (PlayerKVSyncState)typeof(PlayerKVSessionOwner).GetField("state", fields).GetValue(owner);
var coordinator = typeof(PlayerKVSessionOwner).GetField("coordinator", fields).GetValue(owner);
var ticketGate = typeof(PlayerKVSyncCoordinator).GetField("ticketGate", fields).GetValue(coordinator);
var tickets = (System.Collections.IDictionary)typeof(PlayerKVSyncCoordinator).GetField("tickets", fields).GetValue(coordinator);
var admission = typeof(PlayerKVSessionOwner).GetField("admission", fields).GetValue(owner);
var activeOperations = typeof(PlayerKVSessionOwner).GetField("activeOperations", fields);
int TicketCount()
{
lock (ticketGate)
{
return tickets.Count;
}
}
int LeaseCount()
{
lock (admission)
{
return (int)activeOperations.GetValue(owner);
}
}
int SendCount()
{
lock (cadenceGate)
{
return bodies.Count;
}
}
void RequireIdleEditor()
{
if (EditorApplication.isPlayingOrWillChangePlaymode)
{
throw new InvalidOperationException("Cadence validation interrupted by Play mode.");
}
}
var localWrite = store.Write("ticks", "local", false);
Check(localWrite.Accepted && localWrite.Receipt.Ticket == null && state.Inspect().LocalUpdateTicks.ContainsKey("ticks"),
"cadence local-only timestamp is accepted without a remote ticket");
var initialTickets = TicketCount();
var initialStarted = loopContext.Started;
var previousRequest = phaseTimestamp;
cadenceFile = System.IO.Path.Combine(root, "cadence-samples.json");
for (int cycle = 1; cycle <= 2; cycle++)
{
RequireIdleEditor();
var sentBefore = SendCount();
var expected = cycle.ToString(CultureInfo.InvariantCulture);
var written = store.Write("P12A-Cadence", expected);
Check(written.Accepted && written.Receipt.Ticket is PlayerKVSyncTicket, "cadence original remote ticket " + cycle);
Check(SendCount() == sentBefore, "ordinary acceptance never forces a send " + cycle);
var waiting = System.Diagnostics.Stopwatch.StartNew();
while (SendCount() == sentBefore)
{
RequireIdleEditor();
if (waiting.Elapsed.TotalSeconds >= 45)
{
throw new TimeoutException("Cadence original timer did not send within 45 seconds.");
}
await Task.Delay(100);
}
var observation = opened.Handle.WaitForTicketAsync((PlayerKVSyncTicket)written.Receipt.Ticket);
await P6AWait(observation);
Check(observation.Result.Status == PlayerKVTicketStatus.Confirmed, "cadence actual ticket confirmed " + cycle);
waiting.Restart();
while (state.Inspect().ActiveBatch != null || LeaseCount() != 0)
{
RequireIdleEditor();
if (waiting.Elapsed.TotalSeconds >= 5)
{
throw new TimeoutException("Cadence send did not release its actual operation lease.");
}
await Task.Delay(10);
}
RequireIdleEditor();
Dictionary<string, string> sentBody;
long sentAt;
int sends;
lock (cadenceGate)
{
sends = bodies.Count;
sentBody = new Dictionary<string, string>(bodies[sentBefore]);
sentAt = requestTimes[sentBefore];
Check(requestTimes.Count == sends, "cadence request/body samples paired");
}
var seconds = (sentAt - previousRequest) / (double)System.Diagnostics.Stopwatch.Frequency;
previousRequest = sentAt;
Check(seconds >= 39, "cadence real entry interval " + cycle + ": " + seconds);
Check(sends == sentBefore + 1 && sentBody.Count == 1 && sentBody.TryGetValue("P12A-Cadence", out var sentValue) && sentValue == expected,
"cadence exactly one original single-key payload " + cycle);
Check(remote["P12A-Cadence"] == expected && store.Read("P12A-Cadence").ValueOrThrow() == expected && !remote.ContainsKey("ticks"),
"cadence actual remote/local payload and local-only separation " + cycle);
var snapshot = state.Inspect();
var queued = snapshot.OrdinaryBuffers.Sum(bucket => bucket.Count);
Check(snapshot.OrdinaryBuffers.Count == 5 && queued == 0 && snapshot.PreparedOrdinaryBatches.Count == 0 &&
snapshot.OrdinaryUnknownBatches.Count == 0 && snapshot.UnknownBatch == null && snapshot.ActiveBatch == null &&
snapshot.LegacyPending.Count == 0 && snapshot.ExplicitDeletes.Count == 0,
"cadence confirmed queues empty " + cycle);
Check(ReferenceEquals(loop, typeof(KVMgr).GetField("tokenSource", fields).GetValue(manager)), "cadence original timer identity retained " + cycle);
Check(loopContext.Started == initialStarted + cycle, "cadence only one ObserveSync started per original tick " + cycle);
var ticketCount = TicketCount();
var leaseCount = LeaseCount();
Check(ticketCount == initialTickets + cycle && leaseCount == 0, "cadence tickets retained and leases released " + cycle);
var storageBytes = System.IO.Directory.EnumerateFiles(root, "*.json", System.IO.SearchOption.AllDirectories)
.Where(path => !string.Equals(path, cadenceFile, StringComparison.OrdinalIgnoreCase))
.Sum(path => new System.IO.FileInfo(path).Length);
cadenceSamples.Add(new
{
cycle, seconds, sends, requestTimestamp = sentAt, ticketCount, leaseCount, queued,
prepared = snapshot.PreparedOrdinaryBatches.Count, unknown = snapshot.OrdinaryUnknownBatches.Count,
revision = snapshot.Revision, startedDelta = loopContext.Started - initialStarted,
managedBytes = GC.GetTotalMemory(false), storageBytes
});
System.IO.File.WriteAllText(cadenceFile, JsonConvert.SerializeObject(cadenceSamples, Formatting.Indented));
}
}
else
{
for (int i = 0; i < 21; i++)
{
var write = store.Write("k" + i, "v" + i);
Check(write.Accepted, "local acceptance " + i);
receipts.Add((PlayerKVSyncTicket)write.Receipt.Ticket);
}
Call(manager, "OnApplicationPause", true);
await P6AWait(entered.Task);
Check(bodies.Count == 1 && bodies[0].Count == 10, "pause captures one head without waiting HTTP");
Call(manager, "OnApplicationPause", false);
var owner = (PlayerKVSessionOwner)typeof(PlayerKVGameSessionHandle).GetProperty("Owner", fields).GetValue(opened.Handle);
var state = (PlayerKVSyncState)typeof(PlayerKVSessionOwner).GetField("state", fields).GetValue(owner);
Check(state.Inspect().PreparedOrdinaryBatches.Count == 1 && bodies.Count == 1,
"resume immediately captures next head while prior HTTP remains pending");
timer.Restart();
while (state.Inspect().PreparedOrdinaryBatches.Count < 2 && timer.Elapsed.TotalSeconds < 45)
{
await Task.Delay(100);
}
intervalSeconds = timer.Elapsed.TotalSeconds;
Check(intervalSeconds >= 39 && state.Inspect().PreparedOrdinaryBatches.Count == 2 && bodies.Count == 1,
"real forty-second loop captures third head without awaiting HTTP");
Call(manager, "OnApplicationPause", true);
var closedLoop = typeof(KVMgr).GetField("tokenSource", fields).GetValue(manager);
Check(closedLoop == null && state.Inspect().PreparedOrdinaryBatches.Count == 2, "pause stops and empty head never rotates");
release.TrySetResult(true);
foreach (var ticket in receipts)
{
var observation = opened.Handle.WaitForTicketAsync(ticket);
await P6AWait(observation);
Check(observation.Result.Status == PlayerKVTicketStatus.Confirmed, "actual original ticket confirms");
}
Check(bodies.Select(body => body.Count).SequenceEqual(new[] { 10, 10, 1 }) && remote.Count == 21,
"three captured bodies delivered once in order");
var localWrite = store.Write("ticks", "local", false);
Check(localWrite.Receipt.Ticket == null && state.Inspect().LocalUpdateTicks.ContainsKey("ticks"), "high-layer real timestamp and local-only receipt");
}
var before = bodies.Count;
Call(manager, "OnApplicationQuit");
Check(bodies.Count == before, "component quit only stops; user callback owns final attempt");
await bridge.CloseAsync();
Call(manager, "OnDestroy");
Check(instanceField.GetValue(null) == null && bodies.Count == before, "destroy after revoke cannot send or revive identity");
}
catch (Exception ex)
{
failure = ex.ToString();
earlyFailureObserved = failEarly && ex.Message == "P6B expected early fixture failure";
}
finally
{
// Independent cleanup steps retain the first failure and still execute later releases.
void Cleanup(Action action)
{
try
{
action();
}
catch (Exception ex)
{
cleanupErrors.Add(ex.ToString());
}
}
release.TrySetResult(true);
Cleanup(() =>
{
if (shell != null)
{
Call(shell.GetComponent<KVMgr>(), "OnApplicationQuit");
}
});
try
{
if (bridge != null)
{
await bridge.CloseAsync();
}
}
catch (Exception ex)
{
cleanupErrors.Add(ex.ToString());
}
Cleanup(() => KVMgr.Unbind(store));
Cleanup(() => store?.Dispose());
Cleanup(() =>
{
if (shell != null)
{
Call(shell.GetComponent<KVMgr>(), "OnDestroy");
}
});
Cleanup(() =>
{
if (shell != null)
{
UnityEngine.Object.DestroyImmediate(shell);
}
});
Cleanup(() => session?.Dispose());
try
{
// Observe the real async-void lifecycle operations, including their uncancellable Delay.
var idle = loopContext.Idle;
if (await Task.WhenAny(idle, Task.Delay(45000)) != idle)
{
throw new TimeoutException("P6B original lifecycle Delay did not retire.");
}
await idle;
}
catch (Exception ex)
{
cleanupErrors.Add(ex.ToString());
}
finally
{
running = false;
restored = instanceField.GetValue(null) == null && shell == null && loopContext.Active == 0 && cleanupErrors.Count == 0;
}
}
if (verifyCadence)
{
return JsonConvert.SerializeObject(new { success = failure == null && restored, caseId = "P12A-OrdinaryCadence",
assertions, cadenceSamples, cadenceFile, sends = bodies.Count, restored, failure, cleanupErrors,
remainingOperations = loopContext.Active, lifecycleOperations = loopContext.Started, formalRequests = 0,
editorLifecycleDriven = true, runtimeFramesVerified = false, realTimerCycles = cadenceSamples.Count });
}
return JsonConvert.SerializeObject(new { success = (failure == null || earlyFailureObserved) && restored,
caseId = failEarly ? "P6B-OrdinarySave-Cleanup" : "P6B-OrdinarySave", assertions, intervalSeconds,
sends = bodies.Count, restored, failure, earlyFailureObserved, cleanupErrors, remainingOperations = loopContext.Active,
lifecycleOperations = loopContext.Started, formalRequests = 0, editorLifecycleDriven = true, runtimeFramesVerified = false });
}
private sealed class P6BLoopContext : System.Threading.SynchronizationContext
{
private readonly System.Threading.SynchronizationContext original;
private TaskCompletionSource<bool> idle = new TaskCompletionSource<bool>();
internal int Active
{
get;
private set;
}
internal int Started
{
get;
private set;
}
internal Task Idle
{
get
{
return Active == 0 ? Task.CompletedTask : idle.Task;
}
}
internal P6BLoopContext(System.Threading.SynchronizationContext original)
{
this.original = original;
}
public override void OperationStarted()
{
if (Active++ == 0)
{
idle = new TaskCompletionSource<bool>();
}
Started++;
original.OperationStarted();
}
public override void OperationCompleted()
{
original.OperationCompleted();
if (--Active == 0)
{
idle.TrySetResult(true);
}
}
public override void Post(System.Threading.SendOrPostCallback callback, object state)
{
original.Post(value =>
{
var previous = Current;
SetSynchronizationContext(this);
try
{
callback(value);
}
finally
{
SetSynchronizationContext(previous);
}
}, state);
}
}
private static async Task P6AWait(Task task)
{
if (await Task.WhenAny(task, Task.Delay(5000)) != task)
{
throw new TimeoutException("P6A observation exceeded five seconds.");
}
await task;
}
private sealed class P6ATicks : TimeManager.ITimeTickService, IDisposable
{
private readonly Subject<long> seconds = new Subject<long>();
private readonly Subject<long> minutes = new Subject<long>();
public IObservable<long> SecondTick
{
get
{
return seconds;
}
}
public IObservable<long> MinuteTick
{
get
{
return minutes;
}
}
public void Start()
{
}
public void Stop()
{
}
internal void Minute()
{
minutes.OnNext(1);
}
public void Dispose()
{
seconds.Dispose();
minutes.Dispose();
}
}
private sealed class P6AFaultStore : IPlayerSaveStore
{
private readonly bool synchronous;
internal P6AFaultStore(bool synchronous)
{
this.synchronous = synchronous;
}
public bool IsCurrent
{
get
{
return true;
}
}
public Task<bool> SyncDataImmidiate(string key, string value)
{
var error = new InvalidOperationException("P6A synthetic store fault");
if (synchronous)
{
throw error;
}
return Task.FromException<bool>(error);
}
public PlayerSaveReadResult Read(string key)
{
throw new NotSupportedException();
}
public PlayerSaveWriteResult Write(string key, string value, bool remoteStore = true)
{
throw new NotSupportedException();
}
}
private static List<string> P6AInspectStart(Action<bool, string> check)
{
var start = typeof(FishingStage).GetMethod("StartAsync", RetryInstance);
var attribute = (System.Runtime.CompilerServices.AsyncStateMachineAttribute)Attribute.GetCustomAttribute(start, typeof(System.Runtime.CompilerServices.AsyncStateMachineAttribute));
check(attribute != null, "actual StartAsync state machine exists");
var move = attribute.StateMachineType.GetMethod("MoveNext", RetryInstance);
var bytes = move.GetMethodBody().GetILAsByteArray();
var codes = typeof(System.Reflection.Emit.OpCodes).GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static)
.Where(field => field.FieldType == typeof(System.Reflection.Emit.OpCode))
.Select(field => (System.Reflection.Emit.OpCode)field.GetValue(null)).ToDictionary(code => unchecked((ushort)code.Value));
var calls = new List<System.Reflection.MethodBase>();
var evidence = new List<string>();
bool helperDiscarded = false;
for (int cursor = 0; cursor < bytes.Length;)
{
int offset = cursor;
ushort value = bytes[cursor++];
if (value == 0xfe)
{
value = (ushort)(0xfe00 | bytes[cursor++]);
}
var code = codes[value];
int width;
switch (code.OperandType)
{
case System.Reflection.Emit.OperandType.InlineNone:
width = 0;
break;
case System.Reflection.Emit.OperandType.ShortInlineBrTarget:
case System.Reflection.Emit.OperandType.ShortInlineI:
case System.Reflection.Emit.OperandType.ShortInlineVar:
width = 1;
break;
case System.Reflection.Emit.OperandType.InlineVar:
width = 2;
break;
case System.Reflection.Emit.OperandType.InlineI8:
case System.Reflection.Emit.OperandType.InlineR:
width = 8;
break;
case System.Reflection.Emit.OperandType.InlineSwitch:
width = 4 + 4 * BitConverter.ToInt32(bytes, cursor);
break;
default:
width = 4;
break;
}
if (code == System.Reflection.Emit.OpCodes.Call || code == System.Reflection.Emit.OpCodes.Callvirt)
{
var method = move.Module.ResolveMethod(BitConverter.ToInt32(bytes, cursor), attribute.StateMachineType.GetGenericArguments(), Type.EmptyTypes);
calls.Add(method);
evidence.Add(offset.ToString("X4") + " " + method.DeclaringType.FullName + "." + method);
if (method.DeclaringType == typeof(FishingStage) && method.Name == "ObserveLastLoginSaveAsync")
{
var after = cursor + width;
while (after < bytes.Length && bytes[after] == System.Reflection.Emit.OpCodes.Nop.Value)
{
after++;
}
helperDiscarded = after < bytes.Length && bytes[after] == System.Reflection.Emit.OpCodes.Pop.Value;
}
}
cursor += width;
}
int Position(string name)
{
check(calls.Count(method => method.DeclaringType == typeof(FishingStage) && method.Name == name) == 1, "unique actual " + name);
return calls.FindIndex(method => method.DeclaringType == typeof(FishingStage) && method.Name == name);
}
var data = Position("InitData");
var manager = Position("InitManager");
var helper = Position("ObserveLastLoginSaveAsync");
check(data < manager && manager < helper && helperDiscarded, "original initialization order and helper Task pop");
check(calls.Skip(helper + 1).Any(method => method.Name == "RegisterInstance") && calls.Skip(helper + 1).Any(method => method.Name == "Subscribe") && calls.Skip(helper + 1).Any(method => method.Name == "LoadAtlas"), "original registration subscription and atlas remain after helper");
check(!calls.Any(method => method.Name == "SavePlayerData" || method.Name == "FlushAsync" || method.Name == "WriteAndConfirmAsync"), "no additional full save or confirmation call in actual MoveNext");
return evidence;
}
private static async Task<string> RunInitializationLastLogin()
{
if (running || EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating || asap.core.GContext.Ready || UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 || PlayerKVGameplayLoop.Enabled)
{
throw new InvalidOperationException("P6A requires an idle isolated Editor.");
}
running = true;
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var isolated = new asap.core.Container();
var resources = new List<IDisposable>();
var tasks = new List<Task>();
var releases = new List<TaskCompletionSource<bool>>();
var logs = new List<string>();
var errors = new List<string>();
var cases = new List<string>();
var il = new List<string>();
KVUserService user = null;
PlayerKVGameSessionBridge bridge = null;
int assertions = 0, sends = 0, expectedErrors = 0;
bool restored = false;
string failure = null;
void Check(bool condition, string message)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("P6A " + message);
}
}
void Log(string message, string stack, UnityEngine.LogType type)
{
if (type == UnityEngine.LogType.Error || type == UnityEngine.LogType.Exception || type == UnityEngine.LogType.Assert)
{
logs.Add(message);
}
}
UnityEngine.Application.logMessageReceived += Log;
try
{
ValidationContextAccess.Use(isolated);
ValidationContextAccess.Events = new asap.core.EventAggregator();
var directory = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath, "../../cfgData"));
var tables = new cfg.Tables(name => SimpleJSON.JSON.Parse(System.IO.File.ReadAllText(System.IO.Path.Combine(directory, name + ".json"))));
asap.core.ContainerExtensions.RegisterInstance<cfg.Tables>(isolated, tables);
user = new KVUserService();
var ticks = new P6ATicks();
resources.Add(ticks);
int daily = 0;
resources.Add(asap.core.GContext.OnEvent<TimeManager.Event.ActivityCrossDayRefreshEvent>().Subscribe(_ => daily++));
using (var first = new TimeManager.TimeRefreshManager(ticks, user))
{
Check(first.GetLastLoginTime() == null && daily == 1, "missing old login publishes once");
}
cases.Add("missing-login");
var oldProperty = typeof(KVUserService).GetProperty("LastLoginTime");
var today = ZZTimeHelper.UtcNow().UtcNowOffset();
oldProperty.SetValue(user, today);
using (var same = new TimeManager.TimeRefreshManager(ticks, user))
{
Check(daily == 1 && same.GetLastLoginTime() == today, "same day preserves old time without refresh");
}
oldProperty.SetValue(user, today.AddDays(-1));
using (var previous = new TimeManager.TimeRefreshManager(ticks, user))
{
Check(daily == 2 && user.LastLoginTime == today.AddDays(-1), "previous day consumes without replacing old time");
}
cases.Add("same-and-previous-day");
var logStart = logs.Count;
using (var bad = asap.core.GContext.OnEvent<TimeManager.Event.ActivityCrossDayRefreshEvent>().Subscribe(_ => throw new InvalidOperationException("P6A daily subscriber fault")))
using (var manager = new TimeManager.TimeRefreshManager(ticks, user))
{
Check(logs.Skip(logStart).Count(message => message.StartsWith("[TimeRefreshManager] Error during cross day refresh: P6A daily subscriber fault")) == 1, "daily failure caught and construction continues");
expectedErrors++;
bad.Dispose();
var sessionStart = typeof(TimeManager.TimeRefreshManager).GetField("_sessionStartTime", RetryInstance);
sessionStart.SetValue(manager, today.AddDays(-1));
var before = daily;
ticks.Minute();
Check(daily == before + 1, "minute subscription established after caught failure");
manager.Dispose();
sessionStart.SetValue(manager, today.AddDays(-1));
ticks.Minute();
Check(daily == before + 1, "disposed manager no longer consumes ticks");
}
cases.Add("caught-daily-error-and-dispose");
var method = typeof(FishingStage).GetMethod("ObserveLastLoginSaveAsync", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new[] { typeof(IPlayerSaveStore), typeof(string) }, null);
Check(method != null && method.ReturnType == typeof(Task), "actual private helper signature");
Task Observe(IPlayerSaveStore target, string value)
{
var task = (Task)method.Invoke(null, new object[] { target, value });
tasks.Add(task);
return task;
}
foreach (var synchronous in new[] { true, false })
{
logStart = logs.Count;
await P6AWait(Observe(new P6AFaultStore(synchronous), "unused"));
Check(logs.Skip(logStart).Count(message => message.StartsWith("[FishingStage] LastLogin save failed:")) == 1, "one observed helper fault without faulting caller");
expectedErrors++;
}
cases.Add("synchronous-and-task-faults");
var api = new Uri("http://synthetic.invalid/");
var session = new game.Account.S101AccountSession(api, jar => new ValidationHttp(_ =>
{
jar.Add(api, new System.Net.Cookie("sid", "p6a"));
return ValidationJson(new { state = 0, internalId = 17, newCreate = false, createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
}));
resources.Add(session);
var login = session.LoginAsync("101");
tasks.Add(login);
await P6AWait(login);
Check(login.Result.Success, "synthetic session authenticated");
var oldValue = "2026-10-08T00:00:00.0000000Z";
typeof(KVUserService).GetProperty("LoginTime").SetValue(user, session.ServerTimeUtc);
var captured = user.LoginTime.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture);
var remote = new Dictionary<string, string> { ["LastLoginTimeUtc"] = oldValue };
Dictionary<string, string> sent = null;
TaskCompletionSource<bool> entered = null, release = null;
bool fail = false;
bridge = new PlayerKVGameSessionBridge(_ =>
{
var ownerRemote = remote;
return new ValidationHttp(null, async request =>
{
if (request.RequestUri.AbsolutePath.EndsWith("/Get", StringComparison.Ordinal))
{
return ValidationJson(new { data = ownerRemote });
}
sends++;
Dictionary<string, string> body;
using (var reader = new Newtonsoft.Json.JsonTextReader(new System.IO.StringReader(await request.Content.ReadAsStringAsync())))
{
reader.DateParseHandling = DateParseHandling.None;
body = Newtonsoft.Json.Linq.JObject.Load(reader)["data"].ToObject<Dictionary<string, string>>();
}
sent = body;
var requestRelease = release;
var requestFail = fail;
entered.TrySetResult(true);
await requestRelease.Task;
if (!requestFail)
{
foreach (var pair in body)
{
ownerRemote[pair.Key] = pair.Value;
}
}
var response = ValidationJson(new { });
response.StatusCode = requestFail ? System.Net.HttpStatusCode.InternalServerError : System.Net.HttpStatusCode.OK;
return response;
});
});
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath, "../../CodexOutput/upserver/B3BatchMigration/M2/P6-2026-10-09/unity-cache", Guid.NewGuid().ToString("N")));
async Task<KVPlayerSaveStore> Open(string identity, long epoch)
{
var opening = bridge.OpenAsync(session, root, identity, api, epoch, _ => true, default);
tasks.Add(opening);
await P6AWait(opening);
Check(opening.Result.Success, "real owner opened " + identity);
var result = new KVPlayerSaveStore();
result.Bind(opening.Result.Handle, default);
resources.Add(result);
return result;
}
void Gate()
{
entered = new TaskCompletionSource<bool>();
release = new TaskCompletionSource<bool>();
releases.Add(release);
}
var store = await Open("101", 1);
Check(store.Write("P6A-Unrelated", "pending").Accepted, "unrelated ordinary write accepted");
Gate();
var save = Observe(store, captured);
await P6AWait(entered.Task);
bool callerContinued = true;
Check(callerContinued && !save.IsCompleted && sends == 1, "delayed real helper returns pending Task to caller");
Check(sent.Count == 1 && sent["LastLoginTimeUtc"] == captured && !remote.ContainsKey("P6A-Unrelated"), "one captured key excludes unrelated pending");
Check(store.Read("LastLoginTimeUtc").Value == oldValue && user.LastLoginTime == today.AddDays(-1), "old visible times retained before response");
release.TrySetResult(true);
await P6AWait(save);
Check(remote["LastLoginTimeUtc"] == captured && store.Read("LastLoginTimeUtc").Value == oldValue && !remote.ContainsKey("P6A-Unrelated"), "confirmed single write preserves local old value and unrelated pending");
var firstClose = bridge.CloseAsync();
tasks.Add(firstClose);
await P6AWait(firstClose);
store = await Open("101", 2);
Check(store.Read("LastLoginTimeUtc").Value == captured, "new owner Get sees saved timestamp");
cases.Add("single-key-delayed-success-and-reopen");
fail = true;
Gate();
logStart = logs.Count;
save = Observe(store, "2026-10-10T00:00:00.0000000Z");
await P6AWait(entered.Task);
release.TrySetResult(true);
await P6AWait(save);
Check(logs.Skip(logStart).Count(message => message == "[KVMgr::SyncDataImmidiate] Save failed.") == 1 && sends == 2 && remote["LastLoginTimeUtc"] == captured, "500 logged once without retry or false success");
expectedErrors++;
cases.Add("http-500");
fail = false;
Gate();
save = Observe(store, captured);
await P6AWait(entered.Task);
var oldStore = store;
logStart = logs.Count;
var close = bridge.CloseAsync();
tasks.Add(close);
var replacementContainer = new asap.core.Container();
ValidationContextAccess.Use(replacementContainer);
release.TrySetResult(true);
await P6AWait(save);
await P6AWait(close);
var closeErrors = logs.Skip(logStart).ToArray();
Check(closeErrors.All(message => message == "[KVMgr::SyncDataImmidiate] Save failed.") && closeErrors.Length <= 1, "revoked in-flight helper uses existing failure semantics");
expectedErrors += closeErrors.Length;
remote = new Dictionary<string, string> { ["LastLoginTimeUtc"] = "other-owner" };
var otherLogin = session.LoginAsync("102");
tasks.Add(otherLogin);
await P6AWait(otherLogin);
Check(otherLogin.Result.Success && session.PlayerId == "102", "replacement account authenticated with separate cookie jar");
store = await Open("102", 3);
asap.core.ContainerExtensions.RegisterInstance<IPlayerSaveStore>(replacementContainer, store);
var sendBefore = sends;
await P6AWait(Observe(oldStore, "must-not-reach-new-owner"));
Check(sends == sendBefore && remote["LastLoginTimeUtc"] == "other-owner" && store.Read("LastLoginTimeUtc").Value == "other-owner", "stale captured store never resolves replacement account");
cases.Add("revoked-owner-isolation");
il = P6AInspectStart(Check);
cases.Add("actual-start-movenext-il");
Check(logs.Count == expectedErrors, "all error logs accounted for per case");
}
catch (Exception exception)
{
failure = exception.ToString();
}
finally
{
foreach (var release in releases)
{
release.TrySetResult(true);
}
foreach (var task in tasks)
{
try
{
await P6AWait(task);
}
catch (Exception exception)
{
errors.Add("task cleanup: " + exception);
}
}
try
{
if (bridge != null)
{
var finalClose = bridge.CloseAsync();
tasks.Add(finalClose);
await P6AWait(finalClose);
}
}
catch (Exception exception)
{
errors.Add("owner cleanup: " + exception);
}
foreach (var resource in resources.AsEnumerable().Reverse())
{
try
{
resource.Dispose();
}
catch (Exception exception)
{
errors.Add("resource cleanup: " + exception);
}
}
try
{
user?.Logout();
}
catch (Exception exception)
{
errors.Add("user cleanup: " + exception);
}
finally
{
ValidationContextAccess.Use(originalContainer);
ValidationContextAccess.Events = originalEvents;
restored = ReferenceEquals(asap.core.GContext.container, originalContainer) && ReferenceEquals(ValidationContextAccess.Events, originalEvents);
UnityEngine.Application.logMessageReceived -= Log;
running = false;
}
}
return JsonConvert.SerializeObject(new { success = failure == null && errors.Count == 0 && restored && logs.Count == expectedErrors, caseId = "P6A-InitializationLastLogin", assertions, cases, sends, expectedErrors, logs, il, restored, failure, errors, cleanupPending = tasks.Any(task => !task.IsCompleted), fullFishingStageExecuted = false, runtimeFramesVerified = false, formalRequests = 0 });
}
private const System.Reflection.BindingFlags RetryInstance = System.Reflection.BindingFlags.Instance |
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public;
private const System.Reflection.BindingFlags RetryStatic = System.Reflection.BindingFlags.Static |
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public;
private static RetryRun failedRetryCleanup;
private static async Task RetryWait(Func<bool> ready)
{
var deadline = DateTime.UtcNow.AddSeconds(8);
while (!ready())
{
if (DateTime.UtcNow >= deadline)
{
throw new TimeoutException("Login UI observation timed out.");
}
await Task.Delay(10);
}
}
private static async Task RetryComplete(Task work)
{
if (await Task.WhenAny(work, Task.Delay(8000)) != work)
{
throw new TimeoutException("Login UI task did not close.");
}
await work;
}
// Retains the original snapshots if a UI task cannot be closed; Editor validation only.
private sealed class RetryRun
{
private readonly System.Reflection.PropertyInfo selectionProperty = typeof(SubBoostrap).GetProperty("RuntimeSelection", RetryStatic);
private readonly System.Reflection.FieldInfo tableField = typeof(GameCore.LocalizationMgr).GetField("table", RetryStatic);
private readonly System.Reflection.FieldInfo syncField = typeof(UnityAsyncAwaitUtil.SyncContextUtil).GetField("<UnitySynchronizationContext>k__BackingField", RetryStatic);
private readonly System.Reflection.FieldInfo threadField = typeof(UnityAsyncAwaitUtil.SyncContextUtil).GetField("<UnityThreadId>k__BackingField", RetryStatic);
private readonly System.Reflection.FieldInfo runnerField = typeof(UnityAsyncAwaitUtil.AsyncCoroutineRunner).GetField("_instance", RetryStatic);
private readonly object previousSelection;
private readonly object previousTable;
private readonly List<string> previousLanguages;
private readonly bool hadId;
private readonly string previousId;
private readonly object previousSync;
private readonly object previousThread;
private readonly object previousRunner;
private readonly System.Threading.SynchronizationContext context;
private readonly int thread;
private UnityAsyncAwaitUtil.AsyncCoroutineRunner ownedRunner;
private bool subscribed;
internal RetryCase Pending { get; set; }
internal List<string> Errors { get; } = new List<string>();
internal int StoppedRunners { get; private set; }
internal bool Restored { get; private set; }
internal RetryRun()
{
context = System.Threading.SynchronizationContext.Current;
thread = System.Threading.Thread.CurrentThread.ManagedThreadId;
previousRunner = runnerField.GetValue(null);
if (context == null || context.GetType().FullName != "UnityEngine.UnitySynchronizationContext" ||
previousRunner != null || UnityEngine.Resources.FindObjectsOfTypeAll<UnityAsyncAwaitUtil.AsyncCoroutineRunner>().Length != 0)
{
throw new InvalidOperationException("Login UI validation requires the Unity context and no existing coroutine runner.");
}
previousSelection = SubBoostrap.RuntimeSelection;
previousTable = tableField.GetValue(null);
previousLanguages = GameCore.LocalizationMgr.enumLanguage;
hadId = UnityEngine.PlayerPrefs.HasKey("CustomID");
previousId = UnityEngine.PlayerPrefs.GetString("CustomID", string.Empty);
previousSync = syncField.GetValue(null);
previousThread = threadField.GetValue(null);
}
internal void Install()
{
UnityEngine.Application.logMessageReceived += Log;
subscribed = true;
syncField.SetValue(null, context);
threadField.SetValue(null, thread);
selectionProperty.SetValue(null, PlayerKVRuntimeSelection.Capture("kv", PlayerKVRuntimeSelection.FormalApiUrl, false));
var path = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath, "../../cfgData/tbtext.json"));
tableField.SetValue(null, new cfg.TbText(SimpleJSON.JSON.Parse(System.IO.File.ReadAllText(path))));
GameCore.LocalizationMgr.enumLanguage = Enumerable.Repeat("en", Math.Max(1, GameCore.LocalizationMgr.LanguageIndex + 1)).ToList();
}
private void Log(string message, string stack, UnityEngine.LogType type)
{
if (type == UnityEngine.LogType.Error || type == UnityEngine.LogType.Exception)
{
Errors.Add(message + stack);
}
}
private void CheckContext()
{
if (!ReferenceEquals(System.Threading.SynchronizationContext.Current, context) ||
System.Threading.Thread.CurrentThread.ManagedThreadId != thread)
{
throw new InvalidOperationException("Login UI validation left its original Unity context.");
}
}
internal void SetBackend(bool kv)
{
CheckContext();
selectionProperty.SetValue(null, PlayerKVRuntimeSelection.Capture(kv ? "kv" : "playfab", PlayerKVRuntimeSelection.FormalApiUrl, false));
}
internal void OpenRunner()
{
CheckContext();
if (runnerField.GetValue(null) != null || UnityEngine.Resources.FindObjectsOfTypeAll<UnityAsyncAwaitUtil.AsyncCoroutineRunner>().Length != 0)
{
throw new InvalidOperationException("An existing coroutine runner is protected.");
}
ownedRunner = UnityAsyncAwaitUtil.AsyncCoroutineRunner.Instance;
ownedRunner.gameObject.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
}
internal void StopRunner()
{
CheckContext();
if (!ReferenceEquals(runnerField.GetValue(null), ownedRunner))
{
throw new InvalidOperationException("Login UI coroutine runner ownership changed.");
}
if (ownedRunner != null)
{
ownedRunner.StopAllCoroutines();
UnityEngine.Object.DestroyImmediate(ownedRunner.gameObject);
runnerField.SetValue(null, previousRunner);
ownedRunner = null;
StoppedRunners++;
}
if (UnityEngine.Resources.FindObjectsOfTypeAll<UnityAsyncAwaitUtil.AsyncCoroutineRunner>().Length != 0)
{
throw new InvalidOperationException("Login UI coroutine runner was not removed.");
}
}
internal bool Restore()
{
StopRunner();
selectionProperty.SetValue(null, previousSelection);
tableField.SetValue(null, previousTable);
GameCore.LocalizationMgr.enumLanguage = previousLanguages;
if (hadId)
{
UnityEngine.PlayerPrefs.SetString("CustomID", previousId);
}
else
{
UnityEngine.PlayerPrefs.DeleteKey("CustomID");
}
syncField.SetValue(null, previousSync);
threadField.SetValue(null, previousThread);
Restored = ReferenceEquals(SubBoostrap.RuntimeSelection, previousSelection) && ReferenceEquals(tableField.GetValue(null), previousTable) &&
ReferenceEquals(GameCore.LocalizationMgr.enumLanguage, previousLanguages) && UnityEngine.PlayerPrefs.HasKey("CustomID") == hadId &&
UnityEngine.PlayerPrefs.GetString("CustomID", string.Empty) == previousId && ReferenceEquals(syncField.GetValue(null), previousSync) &&
Equals(threadField.GetValue(null), previousThread) && ReferenceEquals(runnerField.GetValue(null), previousRunner) && Pending == null;
if (Restored && subscribed)
{
UnityEngine.Application.logMessageReceived -= Log;
subscribed = false;
}
return Restored;
}
}
private sealed class RetryConfig : asap.core.IConfig
{
private readonly Dictionary<string, object> values = new Dictionary<string, object>();
internal RetryConfig(string id)
{
Set("CustomID", id);
}
public void Set(string key, object value)
{
values[key] = value;
}
public T Get<T>(string key, T fallback)
{
return values.TryGetValue(key, out var value) ? (T)value : fallback;
}
public string this[string key]
{
get
{
return Get(key, string.Empty);
}
}
public float GetFloat(string key, float fallback)
{
return Get(key, fallback);
}
}
// UI responses only; the overridden Login never creates an HTTP handler or calls base.Login.
private sealed class RetryUser : KVUserService, IKVUserLifecycle
{
private readonly Queue<ELoginStep> steps;
private bool ready;
internal List<bool> TokenCalls { get; } = new List<bool>();
internal List<string> Ids { get; } = new List<string>();
internal int Logouts { get; private set; }
internal bool HoldLogin
{
get;
set;
}
internal RetryUser(ELoginStep[] steps)
{
this.steps = new Queue<ELoginStep>(steps);
}
public override Task<ELoginStep> Login(Action<int> progress, bool tyrLoginByToken = true)
{
LoginLifetime.ThrowIfCancellationRequested();
TokenCalls.Add(tyrLoginByToken);
Ids.Add(CustomId);
var step = steps.Dequeue();
ready = step == ELoginStep.Done;
progress?.Invoke(2);
if (HoldLogin)
{
return HoldLoginAsync(step);
}
return Task.FromResult(step);
}
private async Task<ELoginStep> HoldLoginAsync(ELoginStep step)
{
await Task.Delay(System.Threading.Timeout.Infinite, LoginLifetime);
return step;
}
public override void Logout()
{
Logouts++;
base.Logout();
}
bool IKVUserLifecycle.KVHandoffReady => ready && !LoginLifetime.IsCancellationRequested;
PlayerKVGameLoadError IKVUserLifecycle.KVLastError => PlayerKVGameLoadError.Prepare;
Task IKVUserLifecycle.CloseKVForValidationAsync()
{
return CloseKVForValidationAsync();
}
Task<PlayerKVShutdownStatus> IKVUserLifecycle.ObserveKVQuitAsync()
{
return ObserveKVQuitAsync();
}
}
private sealed class RetryRT : IRTService
{
internal int Waits { get; private set; }
public bool IsConnected => false;
public void WaitForAPISvrLogin()
{
Waits++;
}
public Task Connect()
{
throw new InvalidOperationException("UI probe cannot connect.");
}
public Task Disconnect()
{
throw new InvalidOperationException("UI probe cannot disconnect.");
}
public IDisposable OnEvent<T>(Action<T> handler)
{
throw new InvalidOperationException("UI probe cannot subscribe to RT.");
}
public Task<string> Publish(string method, string value)
{
throw new InvalidOperationException("UI probe cannot publish.");
}
public Task<string> Publish(string method, string value, string other)
{
throw new InvalidOperationException("UI probe cannot publish.");
}
public void Release()
{
}
public Task ReleaseAsync()
{
return Task.CompletedTask;
}
}
private sealed class RetrySuccessServices : IInGameMailService, IIAPService
{
internal readonly List<string> Calls = new List<string>();
void IInGameMailService.Init()
{
Calls.Add("mail");
}
void IIAPService.Init()
{
Calls.Add("iap");
}
public bool IsUnlock
{
get
{
throw new InvalidOperationException("Unexpected mail access in login UI validation.");
}
set
{
throw new InvalidOperationException("Unexpected mail access in login UI validation.");
}
}
public void Reset()
{
throw new InvalidOperationException("Unexpected mail reset in login UI validation.");
}
public Task FetchMail()
{
throw new InvalidOperationException("Unexpected mail fetch in login UI validation.");
}
public IList<GameMail> GetAllMail()
{
throw new InvalidOperationException("Unexpected mail read in login UI validation.");
}
public Task<bool> MarkRead(GameMail mail)
{
throw new InvalidOperationException("Unexpected mail write in login UI validation.");
}
public Task<bool> MarkRead(GameMail[] mails = null)
{
throw new InvalidOperationException("Unexpected mail write in login UI validation.");
}
public Task<bool> DelMail(GameMail mail)
{
throw new InvalidOperationException("Unexpected mail deletion in login UI validation.");
}
public Task<bool> DelMail(GameMail[] mails = null)
{
throw new InvalidOperationException("Unexpected mail deletion in login UI validation.");
}
public Task<bool> TakeReward(GameMail mail)
{
throw new InvalidOperationException("Unexpected reward in login UI validation.");
}
public Task<bool> TakeReward(GameMail[] mails = null)
{
throw new InvalidOperationException("Unexpected reward in login UI validation.");
}
public Task<IList<tysdk.SKUDetail>> GetSKUs()
{
throw new InvalidOperationException("Unexpected SKU request in login UI validation.");
}
public Task<tysdk.PaymentInfo> Pay(Action<string> callback, string data, tysdk.SKUDetail sku,
int count, float usdPrice, Newtonsoft.Json.Linq.JObject extra)
{
throw new InvalidOperationException("Unexpected payment in login UI validation.");
}
public Task<Dictionary<string, string>> GetOrderUnreceived()
{
throw new InvalidOperationException("Unexpected order request in login UI validation.");
}
public Task<bool> ConfirmOrders(List<string> ids)
{
throw new InvalidOperationException("Unexpected order confirmation in login UI validation.");
}
public void Release()
{
throw new InvalidOperationException("Unexpected IAP release in login UI validation.");
}
}
private sealed class RetryCase
{
private readonly List<UnityEngine.GameObject> objects = new List<UnityEngine.GameObject>();
private SimpleDialog dialog;
private UnityEngine.GameObject input;
private UnityEngine.UI.InputField inputField;
private UnityEngine.UI.Button inputOk;
private System.Threading.CancellationTokenSource lifetime;
internal PFLoginAct Act { get; private set; }
internal RetryUser User { get; private set; }
internal RetryRT RT { get; private set; }
internal Task Work { get; private set; }
internal RetrySuccessServices SuccessServices { get; private set; }
internal int RemainingObjects => objects.Count(value => value != null);
internal bool InputOpen => input.activeSelf;
private UnityEngine.GameObject Object(string name)
{
var value = new UnityEngine.GameObject("M03B-" + name, typeof(UnityEngine.RectTransform));
value.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
value.SetActive(false);
objects.Add(value);
return value;
}
private static void Field(object target, string name, object value)
{
target.GetType().GetField(name, RetryInstance).SetValue(target, value);
}
internal void Setup(string id, ELoginStep[] steps)
{
User = new RetryUser(steps);
RT = new RetryRT();
Act = Object("act").AddComponent<PFLoginAct>();
Act.userService = User;
Act.config = new RetryConfig(id);
Act.rtService = RT;
SuccessServices = new RetrySuccessServices();
Act.MailService = SuccessServices;
Act.iapService = SuccessServices;
// Stage remains null: the real Unload returns without changing an Editor scene.
dialog = Object("dialog").AddComponent<SimpleDialog>();
var ok = Object("ok").AddComponent<UnityEngine.UI.Button>();
var close = Object("close").AddComponent<UnityEngine.UI.Button>();
Field(dialog, "btn_ok", ok);
Field(dialog, "btn_close", close);
input = Object("input");
inputField = input.AddComponent<UnityEngine.UI.InputField>();
inputOk = Object("input-ok").AddComponent<UnityEngine.UI.Button>();
Field(Act, "dialog", dialog);
Field(Act, "customInput", input);
Field(Act, "customIdInput", inputField);
Field(Act, "inputOkBtn", inputOk);
Field(Act, "loadingInfos", new[] { "synthetic loading" });
lifetime = System.Threading.CancellationTokenSource.CreateLinkedTokenSource(User.LoginLifetime);
Field(Act, "loginLifetime", lifetime);
Field(Act, "loginToken", lifetime.Token);
}
internal void Start()
{
Work = (Task)typeof(PFLoginAct).GetMethod("LoginAsync", RetryInstance).Invoke(Act, null);
}
internal void StartThroughDoLogin()
{
typeof(PFLoginAct).GetMethod("DoLogin", RetryInstance).Invoke(Act, null);
Work = (Task)typeof(PFLoginAct).GetField("loginWork", RetryInstance).GetValue(Act);
if (Work == null)
{
throw new InvalidOperationException("Actual DoLogin did not retain its LoginAsync task.");
}
}
internal void DestroyLoginAct()
{
typeof(PFLoginAct).GetMethod("OnDestroy", RetryInstance).Invoke(Act, null);
lifetime = null;
}
internal Action Callback(bool close)
{
return dialog.gameObject.activeSelf ?
(Action)typeof(SimpleDialog).GetField(close ? "onClose" : "onOk", RetryInstance).GetValue(dialog) : null;
}
internal void Click(bool close)
{
// Idle Editor lifecycle is fixture-driven; invoke the actual component methods.
typeof(SimpleDialog).GetMethod("OnDisable", RetryInstance).Invoke(dialog, null);
typeof(SimpleDialog).GetMethod("OnEnable", RetryInstance).Invoke(dialog, null);
var button = (UnityEngine.UI.Button)typeof(SimpleDialog).GetField(close ? "btn_close" : "btn_ok", RetryInstance).GetValue(dialog);
button.onClick.Invoke();
}
internal void Input(string id)
{
inputField.text = id;
inputOk.onClick.Invoke();
}
internal async Task Close(RetryRun run)
{
User?.Logout();
lifetime?.Cancel();
if (Act != null)
{
typeof(PFLoginAct).GetMethod("StopLoadingInfo", RetryInstance).Invoke(Act, null);
}
if (Work != null)
{
try
{
await RetryComplete(Work);
}
catch (Exception) when (Work.IsCompleted)
{
// The case evaluates its task; cleanup only observes a closed failure/cancellation.
}
}
// The original runtime frame does not advance in this idle Editor.
// Stop only this fixture's coroutine source, never complete the awaiter by hand.
run.StopRunner();
foreach (var value in objects)
{
UnityEngine.Object.DestroyImmediate(value);
}
lifetime?.Dispose();
if (RemainingObjects != 0)
{
throw new InvalidOperationException("Login UI objects were not removed.");
}
}
}
private static async Task<string> RunLoginRetry()
{
if (running || failedRetryCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || PlayerKVGameplayLoop.Enabled ||
asap.core.GContext.Ready || UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 ||
PlayFabMgr.HasLiveInstanceForKVLoad || typeof(LoadingScreen).GetField("_instance", RetryStatic).GetValue(null) != null)
{
throw new InvalidOperationException("Login UI validation requires an idle Editor with no live loading screen.");
}
var run = new RetryRun();
failedRetryCleanup = run;
running = true;
var cases = new List<object>();
string failure = null;
var assertions = 0;
var restored = false;
void Check(bool value, string label)
{
assertions++;
if (!value)
{
throw new InvalidOperationException("Login UI: " + label);
}
}
async Task Case(string name, string id, ELoginStep[] steps, Func<RetryCase, Task> body)
{
var probe = new RetryCase();
run.Pending = probe;
try
{
run.OpenRunner();
probe.Setup(id, steps);
probe.Start();
await body(probe);
Check(probe.Work.Status == TaskStatus.RanToCompletion
? probe.SuccessServices.Calls.SequenceEqual(new[] { "mail", "iap" })
: probe.SuccessServices.Calls.Count == 0,
"only successful login initializes mail then IAP exactly once");
cases.Add(new { name, calls = probe.User.TokenCalls.ToArray(), ids = probe.User.Ids.ToArray(), logoutsBeforeDestroy = probe.User.Logouts });
}
finally
{
await probe.Close(run);
run.Pending = null;
}
}
try
{
run.Install();
await Case("first-done", "101", new[] { ELoginStep.Done }, async probe =>
{
await RetryComplete(probe.Work);
Check(probe.User.TokenCalls.Count == 1 && probe.User.Logouts == 0 && probe.Callback(false) == null,
"first success completes without failure UI or logout");
});
foreach (var close in new[] { false, true })
{
await Case(close ? "retry-close" : "retry-ok", "101", new[] { ELoginStep.Api, ELoginStep.Done }, async probe =>
{
await RetryWait(() => probe.Callback(close) != null);
Check(probe.User.TokenCalls.Count == 1 && probe.User.Logouts == 0 && !probe.Work.IsCompleted,
"failure reaches the original dialog without ending the service");
var old = probe.Callback(close);
probe.Click(close);
old();
await RetryComplete(probe.Work);
Check(probe.User.TokenCalls.Count == 2 && probe.User.TokenCalls.All(value => value) && probe.User.Logouts == 0,
"both original buttons retry with true once and complete login");
});
}
await Case("retry-repeated", "101", new[] { ELoginStep.Api, ELoginStep.Api, ELoginStep.Done }, async probe =>
{
await RetryWait(() => probe.Callback(false) != null);
var old = probe.Callback(false);
probe.Click(false);
await RetryWait(() => probe.Callback(true) != null && !ReferenceEquals(probe.Callback(true), old));
Check(probe.User.TokenCalls.Count == 2 && probe.User.Logouts == 0, "another failure reopens the same original retry loop");
probe.Click(true);
await RetryComplete(probe.Work);
Check(probe.User.TokenCalls.Count == 3 && probe.User.TokenCalls.All(value => value) && probe.RT.Waits == 1,
"repeated failures retain the original option and single RT preparation");
});
await Case("cancel-dialog-old-click", "101", new[] { ELoginStep.Api }, async probe =>
{
await RetryWait(() => probe.Callback(false) != null);
var old = probe.Callback(false);
probe.User.Logout();
try
{
await RetryComplete(probe.Work);
throw new InvalidOperationException("Cancelled retry completed successfully.");
}
catch (OperationCanceledException)
{
Check(probe.Work.IsCanceled, "actual retry task is cancelled");
}
old();
Check(probe.User.TokenCalls.Count == 1 && probe.User.Logouts == 1, "old dialog callback cannot re-enter login after logout");
});
await Case("input-and-retry-input", "{{input}}", new[] { ELoginStep.Api, ELoginStep.Done }, async probe =>
{
await RetryWait(() => probe.InputOpen);
probe.Input("101");
await RetryWait(() => probe.Callback(false) != null);
Check(probe.User.CustomId == "101" && UnityEngine.PlayerPrefs.GetString("CustomID") == "101", "original input stores first identity");
probe.Click(false);
await RetryWait(() => probe.InputOpen);
probe.Input("102");
await RetryComplete(probe.Work);
Check(probe.User.Ids.SequenceEqual(new[] { "101", "102" }) && probe.User.TokenCalls.All(value => value) && probe.User.Logouts == 0 &&
UnityEngine.PlayerPrefs.GetString("CustomID") == "102", "original retry input uses the new ID without restarting");
});
await Case("cancel-input-old-click", "{{input}}", new[] { ELoginStep.Done }, async probe =>
{
await RetryWait(() => probe.InputOpen);
var unchangedId = probe.User.CustomId;
var unchangedPref = UnityEngine.PlayerPrefs.GetString("CustomID", string.Empty);
probe.User.Logout();
try
{
await RetryComplete(probe.Work);
throw new InvalidOperationException("Cancelled input completed successfully.");
}
catch (OperationCanceledException)
{
Check(probe.Work.IsCanceled, "actual input task is cancelled");
}
probe.Input("101");
Check(probe.User.TokenCalls.Count == 0 && probe.User.CustomId == unchangedId &&
UnityEngine.PlayerPrefs.GetString("CustomID", string.Empty) == unchangedPref, "old input click cannot alter identity or enter login");
});
}
catch (Exception ex)
{
failure = ex.ToString();
}
finally
{
if (run.Pending == null)
{
try
{
restored = run.Restore();
if (restored)
{
failedRetryCleanup = null;
running = false;
}
}
catch (Exception ex)
{
failure = failure ?? ex.ToString();
}
}
}
return JsonConvert.SerializeObject(new { success = failure == null && run.Errors.Count == 0 && restored && cases.Count == 7,
caseId = "M03B-LoginRetry", assertions, cases, stoppedOwnedRunners = run.StoppedRunners,
remainingOwnedObjects = run.Pending?.RemainingObjects ?? 0, restored, failure, errors = run.Errors,
runtimeFramesVerified = false, cleanupMode = "owned-runner-stopped", editorLifecycleDriven = true,
formalRequests = 0, realKVLoginExecuted = false, cleanupPending = failedRetryCleanup != null });
}
private static async Task<string> CleanupLoginRetry()
{
var run = failedRetryCleanup;
if (run == null || EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating)
{
throw new InvalidOperationException("No pending login UI owner can be cleaned in this Editor state.");
}
string failure = null;
try
{
if (run.Pending != null)
{
await run.Pending.Close(run);
run.Pending = null;
}
if (run.Restore())
{
failedRetryCleanup = null;
running = false;
}
}
catch (Exception ex)
{
failure = ex.ToString();
}
return JsonConvert.SerializeObject(new { success = run.Restored, caseId = "M03B-LoginRetry-Cleanup", cleanupOnly = true,
restored = run.Restored, failure, errors = run.Errors, cleanupPending = failedRetryCleanup != null,
remainingOwnedObjects = run.Pending?.RemainingObjects ?? 0, runtimeFramesVerified = false, formalRequests = 0 });
}
private static async Task<string> RunCustomId()
{
if (running || failedRetryCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || PlayerKVGameplayLoop.Enabled ||
asap.core.GContext.Ready || UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 ||
PlayFabMgr.HasLiveInstanceForKVLoad || typeof(LoadingScreen).GetField("_instance", RetryStatic).GetValue(null) != null)
{
throw new InvalidOperationException("Custom ID validation requires an idle Editor.");
}
var run = new RetryRun();
failedRetryCleanup = run;
running = true;
var cases = new List<object>();
var assertions = 0;
string failure = null;
var restored = false;
void Check(bool value, string label)
{
assertions++;
if (!value)
{
throw new InvalidOperationException("Custom ID: " + label);
}
}
try
{
run.Install();
foreach (var input in new[]
{
new { kv = true, config = "101", expected = "101" },
new { kv = false, config = "101", expected = "102" },
new { kv = false, config = string.Empty, expected = string.Empty }
})
{
var probe = new RetryCase();
run.Pending = probe;
try
{
run.SetBackend(input.kv);
run.OpenRunner();
probe.Setup(input.config, new[] { ELoginStep.Api });
probe.User.CustomId = "102";
probe.Start();
await RetryWait(() => probe.Callback(false) != null);
Check(probe.User.Ids.SequenceEqual(new[] { input.expected }) && probe.User.CustomId == input.expected,
"actual Login receives the original backend-specific identity");
Check(probe.User.TokenCalls.SequenceEqual(new[] { true }) && probe.User.Logouts == 0 && !probe.Work.IsCompleted,
"one real UI Login call reaches the original retry dialog");
probe.User.Logout();
var cancelled = false;
try
{
await RetryComplete(probe.Work);
}
catch (OperationCanceledException)
{
cancelled = probe.Work.IsCanceled;
}
Check(cancelled, "actual Login task is cancelled before fixture cleanup");
Check(probe.SuccessServices.Calls.Count == 0, "cancelled identity probe does not initialize mail or IAP");
cases.Add(new { backend = input.kv ? "kv" : "playfab", input.config,
ids = probe.User.Ids.ToArray(), calls = probe.User.TokenCalls.ToArray(), cancelled });
}
finally
{
await probe.Close(run);
run.Pending = null;
}
}
}
catch (Exception ex)
{
failure = ex.ToString();
}
finally
{
if (run.Pending == null)
{
try
{
restored = run.Restore();
if (restored)
{
failedRetryCleanup = null;
running = false;
}
}
catch (Exception ex)
{
failure = failure ?? ex.ToString();
}
}
}
return JsonConvert.SerializeObject(new { success = failure == null && run.Errors.Count == 0 && restored && cases.Count == 3,
caseId = "M03C-CustomId", assertions, cases, stoppedOwnedRunners = run.StoppedRunners,
remainingOwnedObjects = run.Pending?.RemainingObjects ?? 0, restored, failure, errors = run.Errors,
runtimeFramesVerified = false, cleanupMode = "owned-runner-stopped", editorLifecycleDriven = true,
formalRequests = 0, realKVLoginExecuted = false, cleanupPending = failedRetryCleanup != null });
}
private static async Task<string> RunDestroyBoundary()
{
if (running || failedRetryCleanup != null || EditorApplication.isPlayingOrWillChangePlaymode ||
EditorApplication.isCompiling || EditorApplication.isUpdating || PlayerKVGameplayLoop.Enabled ||
asap.core.GContext.Ready || UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 ||
PlayFabMgr.HasLiveInstanceForKVLoad || typeof(LoadingScreen).GetField("_instance", RetryStatic).GetValue(null) != null)
{
throw new InvalidOperationException("Login destruction validation requires an idle Editor.");
}
var run = new RetryRun();
failedRetryCleanup = run;
running = true;
var cases = new List<object>();
var assertions = 0;
string failure = null;
var restored = false;
void Check(bool value, string label)
{
assertions++;
if (!value)
{
throw new InvalidOperationException("Login destruction: " + label);
}
}
try
{
run.Install();
var names = new[] { "done-kept", "retry-cancelled", "input-cancelled", "ready-but-pending", "pf-kept", "not-started-kept" };
for (var kind = 0; kind < names.Length; kind++)
{
var probe = new RetryCase();
run.Pending = probe;
try
{
run.SetBackend(kind != 4);
run.OpenRunner();
probe.Setup(kind == 2 ? "{{input}}" : "101",
new[] { kind == 0 || kind == 3 || kind == 5 ? ELoginStep.Done : ELoginStep.Api });
probe.User.CustomId = "102";
probe.User.HoldLogin = kind == 3;
Action oldCallback = null;
if (kind == 5)
{
await probe.User.Login(null);
Check(probe.Work == null && typeof(PFLoginAct).GetField("loginWork", RetryInstance).GetValue(probe.Act) == null,
"unstarted Act has no account work");
}
else
{
probe.StartThroughDoLogin();
Check(ReferenceEquals(probe.Work, typeof(PFLoginAct).GetField("loginWork", RetryInstance).GetValue(probe.Act)),
"actual DoLogin awaits the retained LoginAsync task");
if (kind == 0)
{
await RetryComplete(probe.Work);
Check(probe.Work.Status == TaskStatus.RanToCompletion, "actual login completed before destruction");
}
else if (kind == 1 || kind == 4)
{
await RetryWait(() => probe.Callback(false) != null);
oldCallback = probe.Callback(false);
Check(!probe.Work.IsCompleted && probe.User.TokenCalls.SequenceEqual(new[] { true }), "actual retry is waiting");
}
else if (kind == 2)
{
await RetryWait(() => probe.InputOpen);
Check(!probe.Work.IsCompleted && probe.User.TokenCalls.Count == 0, "actual input is waiting before Login");
}
else
{
await RetryWait(() => probe.User.TokenCalls.Count == 1);
Check(!probe.Work.IsCompleted && ((IKVUserLifecycle)probe.User).KVHandoffReady,
"ready alone cannot finish the actual login work");
}
}
var beforeTask = probe.Work?.Status.ToString() ?? "not-started";
Check(kind == 0
? probe.SuccessServices.Calls.SequenceEqual(new[] { "mail", "iap" })
: probe.SuccessServices.Calls.Count == 0,
"only completed login initializes mail then IAP exactly once");
var beforeServices = probe.SuccessServices.Calls.ToArray();
var beforeCalls = probe.User.TokenCalls.Count;
var beforeId = probe.User.CustomId;
var readyBefore = ((IKVUserLifecycle)probe.User).KVHandoffReady;
Check(!probe.User.LoginLifetime.IsCancellationRequested && probe.User.Logouts == 0, "no fixture Logout before destruction");
probe.DestroyLoginAct();
var actToken = (System.Threading.CancellationToken)typeof(PFLoginAct).GetField("loginToken", RetryInstance).GetValue(probe.Act);
var revoke = kind == 1 || kind == 2 || kind == 3;
Check(actToken.IsCancellationRequested, "actual OnDestroy cancels its child token");
Check(probe.User.Logouts == (revoke ? 1 : 0) && probe.User.LoginLifetime.IsCancellationRequested == revoke,
"only unfinished KV work revokes its parent lifetime");
if (probe.Work != null && kind != 0)
{
var cancelled = false;
try
{
await RetryComplete(probe.Work);
}
catch (OperationCanceledException)
{
cancelled = probe.Work.IsCanceled;
}
Check(cancelled, "actual work ends cancelled before fixture cleanup");
}
else
{
Check(probe.Work == null || probe.Work.Status == TaskStatus.RanToCompletion, "successful or unstarted work remains intact");
}
oldCallback?.Invoke();
if (kind == 2)
{
probe.Input("101");
}
Check(probe.User.TokenCalls.Count == beforeCalls && probe.User.CustomId == beforeId, "old UI callback cannot login or change identity");
Check(((IKVUserLifecycle)probe.User).KVHandoffReady == (!revoke && readyBefore), "completed valid handoff is retained");
Check(probe.SuccessServices.Calls.SequenceEqual(beforeServices), "destruction and old callbacks do not initialize services");
cases.Add(new { name = names[kind], taskBefore = beforeTask, taskAfter = probe.Work?.Status.ToString() ?? "not-started",
actCancelled = actToken.IsCancellationRequested, parentCancelled = probe.User.LoginLifetime.IsCancellationRequested,
logouts = probe.User.Logouts, callsBefore = beforeCalls, callsAfter = probe.User.TokenCalls.Count,
readyBefore, readyAfter = ((IKVUserLifecycle)probe.User).KVHandoffReady });
}
finally
{
await probe.Close(run);
run.Pending = null;
}
}
}
catch (Exception ex)
{
failure = ex.ToString();
}
finally
{
if (run.Pending == null)
{
try
{
restored = run.Restore();
if (restored)
{
failedRetryCleanup = null;
running = false;
}
}
catch (Exception ex)
{
failure = failure ?? ex.ToString();
}
}
}
return JsonConvert.SerializeObject(new { success = failure == null && run.Errors.Count == 0 && restored && cases.Count == 6,
caseId = "M03D-Destroy", assertions, cases, stoppedOwnedRunners = run.StoppedRunners,
remainingOwnedObjects = run.Pending?.RemainingObjects ?? 0, restored, failure, errors = run.Errors,
runtimeFramesVerified = false, cleanupMode = "owned-runner-stopped", editorLifecycleDriven = true,
formalRequests = 0, realKVLoginExecuted = false, cleanupPending = failedRetryCleanup != null });
}
private static async Task<string> RunImmediateConsumers()
{
if (running || EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling || EditorApplication.isUpdating || asap.core.GContext.Ready || UnityEngine.Resources.FindObjectsOfTypeAll<asap.core.GContext>().Length != 0 || PlayerKVGameplayLoop.Enabled)
{
throw new InvalidOperationException("Immediate validation requires an idle isolated Editor.");
}
running = true;
var originalContainer = asap.core.GContext.container;
var originalEvents = ValidationContextAccess.Events;
var isolated = new asap.core.Container();
var bridge = default(PlayerKVGameSessionBridge);
var session = default(game.Account.S101AccountSession);
var shell = default(UnityEngine.GameObject);
var store = default(KVPlayerSaveStore);
var subscriptions = new List<IDisposable>();
var release = default(TaskCompletionSource<bool>);
var errors = new List<string>();
var messages = new List<string>();
int assertions = 0, sends = 0, consumeEvents = 0;
string failure = null;
bool restored = false;
void Check(bool condition)
{
assertions++;
if (!condition)
{
throw new InvalidOperationException("Immediate consumer assertion " + assertions);
}
}
void Set(object target, string name, object value)
{
target.GetType().GetField(name, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).SetValue(target, value);
}
void Log(string message, string stack, UnityEngine.LogType type)
{
messages.Add(message);
if (type == UnityEngine.LogType.Exception)
{
errors.Add(message + stack);
}
}
UnityEngine.Application.logMessageReceived += Log;
try
{
var directory = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath, "../../cfgData"));
var tables = new cfg.Tables(name => SimpleJSON.JSON.Parse(System.IO.File.ReadAllText(System.IO.Path.Combine(directory, name + ".json"))));
var api = new Uri("http://synthetic.invalid/");
session = new game.Account.S101AccountSession(api, jar => new ValidationHttp(_ =>
{
jar.Add(api, new System.Net.Cookie("sid", "module01"));
return ValidationJson(new { state = 0, internalId = 17, newCreate = false, createTime = "2026-01-01T00:00:00Z", svrTime = "2026-10-09T00:00:00Z" });
}));
Check((await session.LoginAsync("101")).Success);
var remote = new Dictionary<string, string>();
Dictionary<string, string> sent = null;
var entered = default(TaskCompletionSource<bool>);
bool fail = false;
bridge = new PlayerKVGameSessionBridge(_ => new ValidationHttp(null, async request =>
{
if (request.RequestUri.AbsolutePath.EndsWith("/Get", StringComparison.Ordinal))
{
return ValidationJson(new { data = remote });
}
sends++;
sent = Newtonsoft.Json.Linq.JObject.Parse(await request.Content.ReadAsStringAsync())["data"].ToObject<Dictionary<string, string>>();
entered.TrySetResult(true);
await release.Task;
var response = ValidationJson(new { });
response.StatusCode = fail ? System.Net.HttpStatusCode.InternalServerError : System.Net.HttpStatusCode.OK;
return response;
}));
var root = System.IO.Path.GetFullPath(System.IO.Path.Combine(UnityEngine.Application.dataPath, "../../CodexOutput/upserver/B3BatchMigration/M2/M01-2026-10-09/unity-cache", Guid.NewGuid().ToString("N")));
var opened = await bridge.OpenAsync(session, root, "101", api, 1, _ => true, default);
Check(opened.Success);
store = new KVPlayerSaveStore();
store.Bind(opened.Handle, default);
ValidationContextAccess.Use(isolated);
ValidationContextAccess.Events = new asap.core.EventAggregator();
asap.core.ContainerExtensions.RegisterInstance<cfg.Tables>(isolated, tables);
var player = new GameCore.PlayerData(tables, null)
{
playerSaveStore = store
};
var small = new GameCore.SmallGameData(tables, null, null);
var fish = new GameCore.PlayerFishData(tables, null);
var achievements = new AchievementDataManager(tables);
var box = new FishingBoxData();
var eventData = new GameCore.FishingEventData(tables);
asap.core.ContainerExtensions.RegisterInstance<GameCore.PlayerData>(isolated, player);
asap.core.ContainerExtensions.RegisterInstance<GameCore.SmallGameData>(isolated, small);
asap.core.ContainerExtensions.RegisterInstance<GameCore.PlayerFishData>(isolated, fish);
asap.core.ContainerExtensions.RegisterInstance<AchievementDataManager>(isolated, achievements);
asap.core.ContainerExtensions.RegisterInstance<FishingBoxData>(isolated, box);
asap.core.ContainerExtensions.RegisterInstance<GameCore.FishingEventData>(isolated, eventData);
eventData.InitData(new Dictionary<string, string>());
typeof(GameCore.PlayerData).GetProperty("benefitsEnergyLimit").SetValue(player, 10000);
Set(player, "vipScoreDic", new Dictionary<int, int> { [0] = 1 });
subscriptions.Add(asap.core.GContext.OnEvent<ConditionTypeEvent>().Subscribe(_ => consumeEvents++));
shell = new UnityEngine.GameObject("M01 immediate consumers");
shell.SetActive(false);
shell.hideFlags = UnityEngine.HideFlags.HideAndDontSave;
var fishing = shell.AddComponent<FishingBehaviorB>();
var panel = shell.AddComponent<FishingTurntablePanel>();
Set(fishing, "saveStore", store);
Set(fishing, "_tables", tables);
Set(fishing, "fishingData", new FishingData { fishItem = tables.TbItem.DataList.First(item => item.SubType != 21 && item.SubType != 22) });
Set(panel, "saveStore", store);
Set(panel, "_fishingEventData", eventData);
panel.wheelLevel = tables.TbWheelLevel.DataList.First();
foreach (var shouldFail in new[]
{
false,
true
}
)
{
fail = shouldFail;
foreach (var isFishing in new[]
{
true,
false
}
)
{
player.SetEnergy(100, false);
player.magnification = 0;
Set(panel, "isDataSynced", false);
var beforeEnergy = (int)player.Energy;
var beforeEvents = consumeEvents;
var beforeSends = sends;
var logStart = messages.Count;
entered = new TaskCompletionSource<bool>();
release = new TaskCompletionSource<bool>();
var target = isFishing ? (object)fishing : panel;
var method = isFishing ? "ConsumeBaitOnPlayfab" : "ConsumeOnPlayfab";
target.GetType().GetMethod(method, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(target, null);
Check(await Task.WhenAny(entered.Task, Task.Delay(5000)) == entered.Task);
var key = isFishing ? "NewPlayerDataDic" : "TurntableRoll";
Check(sent.Count == 1 && sent.ContainsKey(key));
var localBeforeCompletion = store.Read(key);
if (isFishing)
{
Check((int)player.Energy == beforeEnergy - tables.TbEnergyDef.DataList[0].Mag && consumeEvents == beforeEvents + 1);
Check(Newtonsoft.Json.Linq.JObject.Parse(sent[key])["energy"].ToString() == ((int)player.Energy).ToString());
}
else
{
Check(!(bool)typeof(FishingTurntablePanel).GetField("isDataSynced", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(panel));
Check(sent[key] == (eventData.TurntableCoupon - panel.wheelLevel.CostNumber).ToString());
}
release.SetResult(true);
var prefix = isFishing ? "[FishBehaviourB::ConsumeBaitOnPlayfab] " : "[FishingTurntablePanel::ConsumeOnPlayfab] ";
var deadline = DateTime.UtcNow.AddSeconds(5);
while (!messages.Skip(logStart).Contains(prefix + (!fail).ToString()) && errors.Count == 0 && DateTime.UtcNow < deadline)
{
await Task.Delay(10);
}
Check(messages.Skip(logStart).Contains(prefix + (!fail).ToString()) && errors.Count == 0);
var localAfter = store.Read(key);
Check(localBeforeCompletion.Found == localAfter.Found && localBeforeCompletion.Value == localAfter.Value && sends == beforeSends + 1);
if (!isFishing)
{
Check((bool)typeof(FishingTurntablePanel).GetField("isDataSynced", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(panel));
}
}
}
}
catch (Exception ex)
{
failure = ex.ToString();
}
finally
{
release?.TrySetResult(true);
if (bridge != null)
{
await bridge.CloseAsync();
}
store?.Dispose();
session?.Dispose();
foreach (var subscription in subscriptions)
{
subscription.Dispose();
}
if (shell != null)
{
UnityEngine.Object.DestroyImmediate(shell);
}
ValidationContextAccess.Use(originalContainer);
ValidationContextAccess.Events = originalEvents;
restored = ReferenceEquals(asap.core.GContext.container, originalContainer) && ReferenceEquals(ValidationContextAccess.Events, originalEvents);
UnityEngine.Application.logMessageReceived -= Log;
running = false;
}
return JsonConvert.SerializeObject(new { success = failure == null && errors.Count == 0 && restored, caseId = "M01-Immediate", assertions, sends, consumeEvents, restored, failure, errors, formalRequests = 0 });
}
sealed class ValidationHttp : System.Net.Http.HttpMessageHandler
{
private readonly Func<System.Net.Http.HttpRequestMessage,System.Net.Http.HttpResponseMessage> send;
private readonly Func<System.Net.Http.HttpRequestMessage, Task<System.Net.Http.HttpResponseMessage>> sendAsync;
internal ValidationHttp(Func<System.Net.Http.HttpRequestMessage,System.Net.Http.HttpResponseMessage> send,
Func<System.Net.Http.HttpRequestMessage, Task<System.Net.Http.HttpResponseMessage>> sendAsync = null)
{
this.send = send;
this.sendAsync = sendAsync;
}
protected override Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request,System.Threading.CancellationToken token) =>
sendAsync != null ? sendAsync(request) : Task.FromResult(send(request));
}
static System.Net.Http.HttpResponseMessage ValidationJson(object value) => new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK)
{ Content=new System.Net.Http.StringContent(JsonConvert.SerializeObject(value),System.Text.Encoding.UTF8,"application/json") };
internal static Dictionary<string, string> FullRaw(cfg.Tables tables, bool optional)
{
var now = new DateTime(2026, 9, 23, 0, 0, 0, DateTimeKind.Utc);
string day = now.ToString("O", CultureInfo.InvariantCulture), end = now.AddDays(1).ToString("O", CultureInfo.InvariantCulture);
var modern = new Dictionary<string, string>
{
["newData"] = string.Join(",", new[] { "3", "999", "4", "5", "6", "7", tables.TbRodData.DataList[0].ID.ToString(CultureInfo.InvariantCulture), day, "-1", "8", "77", "9", "0", "0", "10", "11", "12", "13", "14" })
};
var raw = new Dictionary<string, string>();
void Put(string key, object value)
{
raw[key] = JsonConvert.SerializeObject(value);
}
if (optional)
{
modern["vipL"] = "1,2";
modern["ld"] = "1.25|2.5|3";
modern["bd"] = "1,2";
modern["ct"] = "1:2";
modern["rt"] = "3:4";
int condition = (int)Enum.GetValues(typeof(cfg.ConditionType)).GetValue(0);
modern["ad"] = condition + ":1|2|3";
Put("NewRodList", new[] { 7, 8 });
raw["SeasonId"] = "9";
raw["IsOpenAppraise"] = "1";
raw["InfiniteBuildingData"] = "synthetic";
foreach (var key in new[]
{
"RodData",
"RodLevelData",
"FishSwimToMap",
"FishSwimToMapCount",
"MapProgress",
"HonorLevelData"
}
)
raw[key] = "{\"-1\":7}";
var fish = tables.TbFishData.DataList.First(f => tables.TbMapData.DataMap.ContainsKey(f.AreaID));
Put("Map_5_" + fish.AreaID, new Dictionary<int, string> { [fish.ID] = "0|-1|2|3|True" });
Put("InitRodAccessoriesData", new { GloveID = 1, RodToSkin = new Dictionary<int, int> { [2] = 3 }, GloveIds = new[] { 4 }, SkinIds = new[] { 5 }, GloveNewIds = new[] { 6 }, SkinNewIds = new[] { 7 } });
raw["ShopPackBuyCount"] = "{\"x\":1}";
raw["ShopAllPackBuyCount"] = "{\"2\":3}";
raw["ShopGiftBuyCount"] = "{\"4\":5}";
raw["Voucher"] = "6";
var daily = new
{
ID = 1,
index = 2,
lastID = 3,
time = "raw"
};
Put("ChainPackDataNew", daily);
Put("TurntableAdData", daily);
Put("VIPAdPackData", new { ID = 7, index = 8, day = 9, cdTime = "raw", isOpen = true });
Put("BuyData", new[] { 1.5, 2.5 });
raw["AdvertAllCount"] = "{\"-2\":10}";
raw["DiamondShopRefreshCount"] = "11";
raw["DiamondShopRefreshTime"] = day;
Put("DiamondShopItemRecords", new Dictionary<int, object> { [12] = new { ItemID = 13, Discount = .5, hasBought = 1 } });
raw["BlackFridayCouponDate"] = "2026,9,23,1,2,3,14,15,1";
Put("LimitedTimeEventDic", new Dictionary<int, object> { [1] = new { id = 2, duration = 9999999d, startTime = day } });
Put("FixedTimeEventDic", new Dictionary<int, object> { [3] = new { id = 4, endTime = end } });
raw["WheelLevelCount"] = "{\"5\":6}";
foreach (var key in new[]
{
"TurntableRoll",
"WheelOperateCount",
"AllWheelOperateCount",
"WheelLevelFreeCount",
"PVPToken"
}
)
raw[key] = "7";
var buff = new
{
SortID = 1,
sourceID = 2,
buffID = 3,
isEnd = false,
buffEndTime = end
};
Put("BuffDataList", new Dictionary<int, object> { [7] = buff });
Put("TargetBuffDataList", new[] { buff });
Put("FishDailyBuff", buff);
Put("GlobalBuffDataList", new Dictionary<int, object> { [7] = buff });
raw["IsFix"] = "true";
raw["IsOpenSkyscraper"] = "1";
raw["CampDataDic"] = "{\"CampId\":205}";
raw["GuideSaveDataNew"] = "A|3|1;B|4|0";
Put("BattlePassRecord", new { ID = 1, Level = 2, Exp = 3, BuyVipToastIndex = 4, IsUnlockVip = 1, NormalRewardGet = new[] { 5, 6 }, VipRewardGet = new[] { 7, 8 }, LastDropIDs = new[] { 9 }, InflationRate = 2.5f });
Put("BattleTask", new { dic_dailyTasks = new Dictionary<int, int> { [9] = 10 }, dic_weeklyTasks = new Dictionary<int, int> { [11] = 12 }, loginDays = new[] { 13, 14 }, DailyTaskEndTime = now, WeeklyTaskEndTime = now.AddDays(1) });
Put("MonthlySignEvent", new { index = 4, dailySignEvent = daily });
Put("TriggerPackDataList", new[] { new { ID = 1, index = 2, lastID = 3, vipLevel = 4, mapID = 5, time = "raw" } });
Put("GiftVIPDData", new Dictionary<string, object> { ["A"] = new { oldVipLevel = 1, curVipLevel = 2, timer = 3 } });
Put("FixedTimeShopDic", new Dictionary<int, object> { [7] = new { id = 8, endTime = end } });
raw["ClubSignin"] = day;
raw["IsOpenClubRed"] = "1";
Put("LureDonateData", new { DonateCountTime = day, ClubLureDonateCount = 7, ClubLureRequestCDEnd = end });
Put("FishingChallengeData", new { FirstOpen = true, EventId = 11, RankTierLevel = 11, Finished = 11, RedirectID = 11, Score = 11, ProcessedScore = 11, step = 11, uiStep = 11, index = 11, StartTime = day, EndTime = end, eliminateNumber = new[] { 7, 9 }, robotAccountList = new[] { 7, 9 }, InflationRate = 1.5f });
var offer = new
{
FirstOpen = true,
EventId = 7,
StartTime = day,
EndTime = end,
ItemId = -1,
LotteryNum = 5,
Items = new[]
{
new
{
Id = 1,
Item = 2,
Number = 3,
Status = 2
}
},
RewardList = new[]
{
8,
9
},
Finished = true,
ChestReward = 10
};
Put("OfferChainsChestData", offer);
Put("OfferDiscoPartyManager", offer);
Put("EventPartnerGatherData", new { FirstOpen = false, EventId = 18, StartTime = day, EndTime = end, CurrentPoints = 1, CurrentMiningProgress = 2, Token = 3, InvitedCount = 4, TicketCount = 5, CompletedNodesList = new[] { new[] { 6, 7 } }, BuilderPartnerScore = new[] { new { Item1 = 8, Item2 = 9 } }, PartnerBonus = new { Item1 = 1.25f, Item2 = end }, FreeSpinNum = 10, Bots = new Dictionary<int, object> { [11] = new { Id = "synthetic-bot", ScorePlayer = 12, ScoreBot = 13, Grade = 14, TargetScore = 15, WakeStartTime = day, WakingSeconds = 16 } }, IsRecvFinalReward = true, UIFinishedPartners = new[] { true, false }, IsFinished = true, SpinState = 2, InflationRate = 2.5f, IsEnableAutoMatch = true, LastAutoMatchTime = day });
Put("EventCubeMeltData", new { TicketCount = 1, FirstOpen = true, IsFinished = true, EventId = 2, IsInGuide = true, StartTime = day, EndTime = end, CurrentStagetId = 3, CollectItems = new[] { new { ItemId = 4, Count = 5, MaxCount = 6, ItemTrueId = 7 } }, BoardData = new[] { 8, 9 }, BoardViewSize = new { x = 10, y = 11 }, CollectRewardsId = new[] { 12, 13 }, IsFinalRewardGet = true, PieceDatas = new[] { new[] { 14, 15 }, new[] { 16, 17 } }, Cycle = 18, InflationRate = 1.5f });
Put("EventPackData", new { currentEventID = -1, purchaseCount = 2, VIPLvlWhenEventActivate = 3, redirectID = 4 });
Put("PiggyBankPackData", new { currentEventID = 11, purchaseCount = 11, VIPLvlWhenEventActivate = 11, savingProgress = 11, redirectID = 0, doNeedTrigger = true, isTriggered = true, inflation = 1.5f });
Put("GeneralEventPackData", new { currentEventID = 11, redirectID = tables.TbEventPackManager.DataList.First(p => p.PackType == 3).ID, VIPLvlWhenEventActivate = 11, purchaseCount = 11, savingProgress = 11, discountLvl = 11, visualProgress = 11, visualDiscountLvl = 11, rodID = 11, lastPackIDBought = 11, packID = 11, doNeedTrigger = true, isTriggered = true, inflation = 1.5f, selections = new[] { 7, 9 } });
raw["FootPrint"] = "18446744073709551615";
Put("EventShootingRangeData", new { EventId = 11, CycleId = 11, RedirectId = 11, AmmoCount = 11, CurrentStageIdx = 11, ChainProgress = 11, RewardFlag = long.MaxValue, TargetFlag = long.MinValue, HasBeenOpened = true, Inflation = 1.5f });
var item = new
{
name = "synthetic",
index = 3,
isOver = true,
DataType = 2,
ColorTypeList = new[]
{
7,
9
},
ShelfTypeList = new[]
{
0,
1
},
GridStateList = new[]
{
0,
5
},
FromDisplayAreaIndexList = new[]
{
1,
2
}
};
Put("epdk", new { EventID = 11, PotionID = 11, StageID = 11, Stage1TotalLevel = 11, Stage2TotalLevel = 11, LevelID = 11, LevelIndex = 11, CorrectNum = 11, SubmitNum = 11, Token = 11, ConsumedToken = 11, Rule = 11, PreEventID = 11, PrePotionID = 11, PreStageID = 11, PreLevelID = 11, Round = 11, FirstPlayedEventId = 11, IsOver = true, Name = "synthetic", InflationRate = 1.5f, LevelTargetData = item, LevelDisplayData = item, LevelProcessedList = new[] { item } });
Put("epbdk", new { EventID = 11, PinballMainID = 11, SpinPoint = 11, Scores = 11, Multiple = 11, Token = 11, ConsumedToken = 11, RewardIndex = 11, Force = 1.5f, LuckyValue = 1.5f, InflationRate = 1.5f });
Put("estdk", new { EventID = 11, ScratchMainID = 11, ChainPackID = 11, Token = 11, ConsumedToken = 11, RewardTaskConsumedToken = 11, EventScratchRewardTaskID = 11, EventScratchCardID = 11, TotalConsumedToken = 11, ChainPackProgress = 11, magIndex = 11, IsOver = true, LuckyValue = 1.5f, InflationRate = 1.5f, StampRewardList = new[] { 7, 9 }, StampRewardDict = new Dictionary<int, object> { [7] = new { EventScratchCardID = 8, Count = 9 } } });
raw["ThanksGivingPackData"] = "1,2,3,4";
raw["ThanksGivingPackMigrationData"] = "5,6,7,8";
Put("EventPinataPackData", new { EventID = 7, PinataMainID = 8, PurchasedCount = 9 });
raw["EAccoutUrl"] = "{\"synthetic\":\"avatar\"}";
raw["hwGoogle"] = "1";
raw["Apple"] = "1";
raw["TapJoy_Diamond"] = "12";
}
Put("NewPlayerDataDic", modern);
return raw;
}
// A static access shim only; never added as a component or instantiated.
sealed class ValidationContextAccess : asap.core.GContext
{
protected override Task SetupAsync() => throw new InvalidOperationException("Not a gameplay context.");
internal static void Use(asap.core.Container value) { container = value; }
internal static asap.core.IEventAggregator Events { get => eventAggregator; set => eventAggregator = value; }
}
static bool running;
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink