Add test codes

Jack251970 · Jack251970 · commit 236abc8d2253 · 2025-04-17T19:02:48.000+08:00
diff --git a/Flow.Launcher/ViewModel/MainViewModel.cs b/Flow.Launcher/ViewModel/MainViewModel.cs
@@ -307,6 +307,7 @@ public void ReQuery()
         {
             if (QueryResultsSelected())
             {
+                App.API.LogDebug(ClassName, $"Search Delay: {false}, Is Requery: {true}, Reselect: {true}");
                 // When we are re-querying, we should not delay the query
                 _ = QueryResultsAsync(false, isReQuery: true);
             }
@@ -315,6 +316,7 @@ public void ReQuery()
         public void ReQuery(bool reselect)
         {
             BackToQueryResults();
+            App.API.LogDebug(ClassName, $"Search Delay: {false}, Is Requery: {true}, Reselect: {reselect}");
             // When we are re-querying, we should not delay the query
             _ = QueryResultsAsync(false, isReQuery: true, reSelect: reselect);
         }
@@ -1077,6 +1079,7 @@ public void Query(bool searchDelay, bool isReQuery = false)
         {
             if (QueryResultsSelected())
             {
+                App.API.LogDebug(ClassName, $"Search Delay: {searchDelay}, Is Requery: {isReQuery}, Reselect: {true}");
                 _ = QueryResultsAsync(searchDelay, isReQuery);
             }
             else if (ContextMenuSelected())
@@ -1093,6 +1096,7 @@ private async Task QueryAsync(bool searchDelay, bool isReQuery = false)
         {
             if (QueryResultsSelected())
             {
+                App.API.LogDebug(ClassName, $"Search Delay: {searchDelay}, Is Requery: {isReQuery}, Reselect: {true}");
                 await QueryResultsAsync(searchDelay, isReQuery);
             }
             else if (ContextMenuSelected())
@@ -1196,22 +1200,26 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b
         {
             _updateSource?.Cancel();
 
+            App.API.LogDebug(ClassName, $"Query construct for QueryText: {QueryText}");
+
             var query = ConstructQuery(QueryText, Settings.CustomShortcuts, Settings.BuiltinShortcuts);
 
             if (query == null) // shortcut expanded
             {
+                App.API.LogDebug(ClassName, $"Query null for QueryText: null");
+
                 // Wait last query to be canceled and then do resetting actions
                 await _updateLock.WaitAsync(CancellationToken.None);
                 try
                 {
                     // Reset results
-                Results.Clear();
-                Results.Visibility = Visibility.Collapsed;
+                    Results.Clear();
+                    Results.Visibility = Visibility.Collapsed;
 
                     // Reset plugin icon
-                PluginIconPath = null;
-                PluginIconSource = null;
-                SearchIconVisibility = Visibility.Visible;
+                    PluginIconPath = null;
+                    PluginIconSource = null;
+                    SearchIconVisibility = Visibility.Visible;
 
                     // Reset progress bar
                     ProgressBarVisibility = Visibility.Hidden;
@@ -1226,6 +1234,8 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b
             // Switch to ThreadPool thread to keep UI responsive when waiting update lock
             await TaskScheduler.Default;
 
+            App.API.LogDebug(ClassName, $"Wait for QueryText: {query.RawQuery}");
+
             await _updateLock.WaitAsync(CancellationToken.None);
             try
             {
@@ -1235,24 +1245,34 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b
 
                 ProgressBarVisibility = Visibility.Hidden;
 
+                App.API.LogDebug(ClassName, $"Start for QueryText: {query.RawQuery}");
+                App.API.LogDebug(ClassName, $"ProgressBar: {Visibility.Hidden}");
+
                 _runningQuery = query;
 
                 // Switch to ThreadPool thread
                 await TaskScheduler.Default;
 
                 if (_updateSource.Token.IsCancellationRequested)
+                {
+                    App.API.LogDebug(ClassName, $"Cancel for QueryText: {query.RawQuery}");
                     return;
+                }
 
                 // Update the query's IsReQuery property to true if this is a re-query
                 query.IsReQuery = isReQuery;
 
                 // handle the exclusiveness of plugin using action keyword
                 RemoveOldQueryResults(query);
 
+                App.API.LogDebug(ClassName, $"Remove old for QueryText: {query.RawQuery}");
+
                 _lastQuery = query;
 
                 var plugins = PluginManager.ValidPluginsForQuery(query);
 
+                App.API.LogDebug(ClassName, $"Valid {plugins.Count} plugins QueryText: {query.RawQuery}");
+
                 if (plugins.Count == 1)
                 {
                     PluginIconPath = plugins.Single().Metadata.IcoPath;
@@ -1278,10 +1298,14 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b
 
                 _ = Task.Delay(200, _updateSource.Token).ContinueWith(_ =>
                     {
+                        App.API.LogDebug(ClassName, $"Check ProgressBar for QueryText: running: {_runningQuery?.RawQuery ?? "null"} query: {query.RawQuery}");
+
                         // start the progress bar if query takes more than 200 ms and this is the current running query and it didn't finish yet
                         if (_runningQuery != null && _runningQuery == query)
                         {
                             ProgressBarVisibility = Visibility.Visible;
+
+                            App.API.LogDebug(ClassName, $"ProgressBar: {Visibility.Visible}");
                         }
                     },
                     _updateSource.Token,
@@ -1307,7 +1331,10 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b
                 }
 
                 if (_updateSource.Token.IsCancellationRequested)
+                {
+                    App.API.LogDebug(ClassName, $"Cancel for QueryText: {QueryText}");
                     return;
+                }
 
                 // this should happen once after all queries are done so progress bar should continue
                 // until the end of all querying
@@ -1317,10 +1344,13 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b
                 {
                     // update to hidden if this is still the current query
                     ProgressBarVisibility = Visibility.Hidden;
+
+                    App.API.LogDebug(ClassName, $"ProgressBar: {Visibility.Hidden}");
                 }
             }
             finally
             {
+                App.API.LogDebug(ClassName, $"Query return for QueryText: {QueryText}");
                 _updateLock.Release();
             }
 
@@ -1334,7 +1364,10 @@ async Task QueryTaskAsync(PluginPair plugin)
                     await Task.Delay(searchDelayTime, _updateSource.Token);
 
                     if (_updateSource.Token.IsCancellationRequested)
+                    {
+                        App.API.LogDebug(ClassName, $"Cancel for QueryText: {QueryText}");
                         return;
+                    }
                 }
 
                 // Since it is wrapped within a ThreadPool Thread, the synchronous context is null
@@ -1344,7 +1377,10 @@ async Task QueryTaskAsync(PluginPair plugin)
                 var results = await PluginManager.QueryForPluginAsync(plugin, query, _updateSource.Token);
 
                 if (_updateSource.Token.IsCancellationRequested)
+                {
+                    App.API.LogDebug(ClassName, $"Cancel for QueryText: {query.RawQuery}");
                     return;
+                }
 
                 IReadOnlyList<Result> resultsCopy;
                 if (results == null)
@@ -1366,13 +1402,20 @@ async Task QueryTaskAsync(PluginPair plugin)
                 }
 
                 if (_updateSource.Token.IsCancellationRequested)
+                {
+                    App.API.LogDebug(ClassName, $"Cancel for QueryText: {query.RawQuery}");
                     return;
+                }
 
                 if (!_resultsUpdateChannelWriter.TryWrite(new ResultsForUpdate(resultsCopy, plugin.Metadata, query,
                     _updateSource.Token, reSelect)))
                 {
                     App.API.LogError(ClassName, "Unable to add item to Result Update Queue");
                 }
+                else
+                {
+                    App.API.LogDebug(ClassName, $"Write updates for QueryText: {query.RawQuery}");
+                }
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -307,6 +307,7 @@ public void ReQuery()`
`307`	`307`	`{`
`308`	`308`	`if (QueryResultsSelected())`
`309`	`309`	`{`
	`310`	`+ App.API.LogDebug(ClassName, $"Search Delay: {false}, Is Requery: {true}, Reselect: {true}");`
`310`	`311`	`// When we are re-querying, we should not delay the query`
`311`	`312`	`_ = QueryResultsAsync(false, isReQuery: true);`
`312`	`313`	`}`
`@@ -315,6 +316,7 @@ public void ReQuery()`
`315`	`316`	`public void ReQuery(bool reselect)`
`316`	`317`	`{`
`317`	`318`	`BackToQueryResults();`
	`319`	`+ App.API.LogDebug(ClassName, $"Search Delay: {false}, Is Requery: {true}, Reselect: {reselect}");`
`318`	`320`	`// When we are re-querying, we should not delay the query`
`319`	`321`	`_ = QueryResultsAsync(false, isReQuery: true, reSelect: reselect);`
`320`	`322`	`}`
`@@ -1077,6 +1079,7 @@ public void Query(bool searchDelay, bool isReQuery = false)`
`1077`	`1079`	`{`
`1078`	`1080`	`if (QueryResultsSelected())`
`1079`	`1081`	`{`
	`1082`	`+ App.API.LogDebug(ClassName, $"Search Delay: {searchDelay}, Is Requery: {isReQuery}, Reselect: {true}");`
`1080`	`1083`	`_ = QueryResultsAsync(searchDelay, isReQuery);`
`1081`	`1084`	`}`
`1082`	`1085`	`else if (ContextMenuSelected())`
`@@ -1093,6 +1096,7 @@ private async Task QueryAsync(bool searchDelay, bool isReQuery = false)`
`1093`	`1096`	`{`
`1094`	`1097`	`if (QueryResultsSelected())`
`1095`	`1098`	`{`
	`1099`	`+ App.API.LogDebug(ClassName, $"Search Delay: {searchDelay}, Is Requery: {isReQuery}, Reselect: {true}");`
`1096`	`1100`	`await QueryResultsAsync(searchDelay, isReQuery);`
`1097`	`1101`	`}`
`1098`	`1102`	`else if (ContextMenuSelected())`
`@@ -1196,22 +1200,26 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b`
`1196`	`1200`	`{`
`1197`	`1201`	`_updateSource?.Cancel();`
`1198`	`1202`
	`1203`	`+ App.API.LogDebug(ClassName, $"Query construct for QueryText: {QueryText}");`
	`1204`	`+`
`1199`	`1205`	`var query = ConstructQuery(QueryText, Settings.CustomShortcuts, Settings.BuiltinShortcuts);`
`1200`	`1206`
`1201`	`1207`	`if (query == null) // shortcut expanded`
`1202`	`1208`	`{`
	`1209`	`+ App.API.LogDebug(ClassName, $"Query null for QueryText: null");`
	`1210`	`+`
`1203`	`1211`	`// Wait last query to be canceled and then do resetting actions`
`1204`	`1212`	`await _updateLock.WaitAsync(CancellationToken.None);`
`1205`	`1213`	`try`
`1206`	`1214`	`{`
`1207`	`1215`	`// Reset results`
`1208`		`- Results.Clear();`
`1209`		`- Results.Visibility = Visibility.Collapsed;`
	`1216`	`+ Results.Clear();`
	`1217`	`+ Results.Visibility = Visibility.Collapsed;`
`1210`	`1218`
`1211`	`1219`	`// Reset plugin icon`
`1212`		`- PluginIconPath = null;`
`1213`		`- PluginIconSource = null;`
`1214`		`- SearchIconVisibility = Visibility.Visible;`
	`1220`	`+ PluginIconPath = null;`
	`1221`	`+ PluginIconSource = null;`
	`1222`	`+ SearchIconVisibility = Visibility.Visible;`
`1215`	`1223`
`1216`	`1224`	`// Reset progress bar`
`1217`	`1225`	`ProgressBarVisibility = Visibility.Hidden;`
`@@ -1226,6 +1234,8 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b`
`1226`	`1234`	`// Switch to ThreadPool thread to keep UI responsive when waiting update lock`
`1227`	`1235`	`await TaskScheduler.Default;`
`1228`	`1236`
	`1237`	`+ App.API.LogDebug(ClassName, $"Wait for QueryText: {query.RawQuery}");`
	`1238`	`+`
`1229`	`1239`	`await _updateLock.WaitAsync(CancellationToken.None);`
`1230`	`1240`	`try`
`1231`	`1241`	`{`
`@@ -1235,24 +1245,34 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b`
`1235`	`1245`
`1236`	`1246`	`ProgressBarVisibility = Visibility.Hidden;`
`1237`	`1247`
	`1248`	`+ App.API.LogDebug(ClassName, $"Start for QueryText: {query.RawQuery}");`
	`1249`	`+ App.API.LogDebug(ClassName, $"ProgressBar: {Visibility.Hidden}");`
	`1250`	`+`
`1238`	`1251`	`_runningQuery = query;`
`1239`	`1252`
`1240`	`1253`	`// Switch to ThreadPool thread`
`1241`	`1254`	`await TaskScheduler.Default;`
`1242`	`1255`
`1243`	`1256`	`if (_updateSource.Token.IsCancellationRequested)`
	`1257`	`+ {`
	`1258`	`+ App.API.LogDebug(ClassName, $"Cancel for QueryText: {query.RawQuery}");`
`1244`	`1259`	`return;`
	`1260`	`+ }`
`1245`	`1261`
`1246`	`1262`	`// Update the query's IsReQuery property to true if this is a re-query`
`1247`	`1263`	`query.IsReQuery = isReQuery;`
`1248`	`1264`
`1249`	`1265`	`// handle the exclusiveness of plugin using action keyword`
`1250`	`1266`	`RemoveOldQueryResults(query);`
`1251`	`1267`
	`1268`	`+ App.API.LogDebug(ClassName, $"Remove old for QueryText: {query.RawQuery}");`
	`1269`	`+`
`1252`	`1270`	`_lastQuery = query;`
`1253`	`1271`
`1254`	`1272`	`var plugins = PluginManager.ValidPluginsForQuery(query);`
`1255`	`1273`
	`1274`	`+ App.API.LogDebug(ClassName, $"Valid {plugins.Count} plugins QueryText: {query.RawQuery}");`
	`1275`	`+`
`1256`	`1276`	`if (plugins.Count == 1)`
`1257`	`1277`	`{`
`1258`	`1278`	`PluginIconPath = plugins.Single().Metadata.IcoPath;`
`@@ -1278,10 +1298,14 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b`
`1278`	`1298`
`1279`	`1299`	`_ = Task.Delay(200, _updateSource.Token).ContinueWith(_ =>`
`1280`	`1300`	`{`
	`1301`	`+ App.API.LogDebug(ClassName, $"Check ProgressBar for QueryText: running: {_runningQuery?.RawQuery ?? "null"} query: {query.RawQuery}");`
	`1302`	`+`
`1281`	`1303`	`// start the progress bar if query takes more than 200 ms and this is the current running query and it didn't finish yet`
`1282`	`1304`	`if (_runningQuery != null && _runningQuery == query)`
`1283`	`1305`	`{`
`1284`	`1306`	`ProgressBarVisibility = Visibility.Visible;`
	`1307`	`+`
	`1308`	`+ App.API.LogDebug(ClassName, $"ProgressBar: {Visibility.Visible}");`
`1285`	`1309`	`}`
`1286`	`1310`	`},`
`1287`	`1311`	`_updateSource.Token,`
`@@ -1307,7 +1331,10 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b`
`1307`	`1331`	`}`
`1308`	`1332`
`1309`	`1333`	`if (_updateSource.Token.IsCancellationRequested)`
	`1334`	`+ {`
	`1335`	`+ App.API.LogDebug(ClassName, $"Cancel for QueryText: {QueryText}");`
`1310`	`1336`	`return;`
	`1337`	`+ }`
`1311`	`1338`
`1312`	`1339`	`// this should happen once after all queries are done so progress bar should continue`
`1313`	`1340`	`// until the end of all querying`
`@@ -1317,10 +1344,13 @@ private async Task QueryResultsAsync(bool searchDelay, bool isReQuery = false, b`
`1317`	`1344`	`{`
`1318`	`1345`	`// update to hidden if this is still the current query`
`1319`	`1346`	`ProgressBarVisibility = Visibility.Hidden;`
	`1347`	`+`
	`1348`	`+ App.API.LogDebug(ClassName, $"ProgressBar: {Visibility.Hidden}");`
`1320`	`1349`	`}`
`1321`	`1350`	`}`
`1322`	`1351`	`finally`
`1323`	`1352`	`{`
	`1353`	`+ App.API.LogDebug(ClassName, $"Query return for QueryText: {QueryText}");`
`1324`	`1354`	`_updateLock.Release();`
`1325`	`1355`	`}`
`1326`	`1356`
`@@ -1334,7 +1364,10 @@ async Task QueryTaskAsync(PluginPair plugin)`
`1334`	`1364`	`await Task.Delay(searchDelayTime, _updateSource.Token);`
`1335`	`1365`
`1336`	`1366`	`if (_updateSource.Token.IsCancellationRequested)`
	`1367`	`+ {`
	`1368`	`+ App.API.LogDebug(ClassName, $"Cancel for QueryText: {QueryText}");`
`1337`	`1369`	`return;`
	`1370`	`+ }`
`1338`	`1371`	`}`
`1339`	`1372`
`1340`	`1373`	`// Since it is wrapped within a ThreadPool Thread, the synchronous context is null`
`@@ -1344,7 +1377,10 @@ async Task QueryTaskAsync(PluginPair plugin)`
`1344`	`1377`	`var results = await PluginManager.QueryForPluginAsync(plugin, query, _updateSource.Token);`
`1345`	`1378`
`1346`	`1379`	`if (_updateSource.Token.IsCancellationRequested)`
	`1380`	`+ {`
	`1381`	`+ App.API.LogDebug(ClassName, $"Cancel for QueryText: {query.RawQuery}");`
`1347`	`1382`	`return;`
	`1383`	`+ }`
`1348`	`1384`
`1349`	`1385`	`IReadOnlyList<Result> resultsCopy;`
`1350`	`1386`	`if (results == null)`
`@@ -1366,13 +1402,20 @@ async Task QueryTaskAsync(PluginPair plugin)`
`1366`	`1402`	`}`
`1367`	`1403`
`1368`	`1404`	`if (_updateSource.Token.IsCancellationRequested)`
	`1405`	`+ {`
	`1406`	`+ App.API.LogDebug(ClassName, $"Cancel for QueryText: {query.RawQuery}");`
`1369`	`1407`	`return;`
	`1408`	`+ }`
`1370`	`1409`
`1371`	`1410`	`if (!_resultsUpdateChannelWriter.TryWrite(new ResultsForUpdate(resultsCopy, plugin.Metadata, query,`
`1372`	`1411`	`_updateSource.Token, reSelect)))`
`1373`	`1412`	`{`
`1374`	`1413`	`App.API.LogError(ClassName, "Unable to add item to Result Update Queue");`
`1375`	`1414`	`}`
	`1415`	`+ else`
	`1416`	`+ {`
	`1417`	`+ App.API.LogDebug(ClassName, $"Write updates for QueryText: {query.RawQuery}");`
	`1418`	`+ }`
`1376`	`1419`	`}`
`1377`	`1420`	`}`
`1378`	`1421`