language stringclasses 1 value | repo stringclasses 133 values | path stringlengths 13 229 | class_span dict | source stringlengths 14 2.92M | target stringlengths 1 153 |
|---|---|---|---|---|---|
csharp | getsentry__sentry-dotnet | test/Sentry.DiagnosticSource.Tests/Integration/SQLite/SentryDiagnosticListenerTests.cs | {
"start": 223,
"end": 7287
} | private class ____
{
private readonly Database _database;
public IHub Hub { get; set; }
internal SentryScopeManager ScopeManager { get; }
public Fixture()
{
// We're skipping not just the tests but here too.
// Fixture creation breaks on Mono due to `Library e_sqlite3 not found`.
if (RuntimeInfo.GetRuntime().IsMono())
{
return;
}
var options = new SentryOptions
{
TracesSampleRate = 1.0,
IsGlobalModeEnabled = false
};
var client = Substitute.For<ISentryClient>();
ScopeManager = new SentryScopeManager(options, client);
Hub = Substitute.For<IHub>();
Hub.GetSpan().ReturnsForAnyArgs(_ => GetSpan());
Hub.StartTransaction(Arg.Any<ITransactionContext>(), Arg.Any<IReadOnlyDictionary<string, object>>())
.ReturnsForAnyArgs(callinfo => StartTransaction(Hub, callinfo.Arg<ITransactionContext>()));
Hub.When(hub => hub.ConfigureScope(Arg.Any<Action<Scope>>()))
.Do(callback => callback.Arg<Action<Scope>>().Invoke(ScopeManager.GetCurrent().Key));
DiagnosticListener.AllListeners.Subscribe(new SentryDiagnosticSubscriber(Hub, options));
_database = new Database();
_database.Seed();
}
public ItemsContext NewContext() => new(_database.ContextOptions);
public ISpan GetSpan() => ScopeManager.GetCurrent().Key.Span;
public ITransactionTracer StartTransaction(IHub hub, ITransactionContext context)
{
var transaction = new TransactionTracer(hub, context);
var (currentScope, _) = ScopeManager.GetCurrent();
currentScope.Transaction = transaction;
return transaction;
}
}
private readonly Fixture _fixture = new();
[SkippableFact]
public void EfCoreIntegration_RunSynchronousQueryWithIssue_TransactionWithSpans()
{
Skip.If(RuntimeInfo.GetRuntime().IsMono());
// Arrange
var hub = _fixture.Hub;
var transaction = hub.StartTransaction("test", "test");
var spans = transaction.Spans;
var context = _fixture.NewContext();
Exception exception = null;
// Act
try
{
_ = context.Items.FromSqlRaw("SELECT * FROM Items :)").ToList();
}
catch (Exception ex)
{
exception = ex;
}
// Assert
Assert.NotNull(exception);
#if NETFRAMEWORK
Assert.Single(spans); //1 command
#else
Assert.Equal(2, spans.Count); //1 query compiler, 1 command
Assert.Single(spans, s => s is { Status: SpanStatus.Ok, Operation: "db.query.compile" });
#endif
Assert.Single(spans, s => s is { Status: SpanStatus.InternalError, Operation: "db.query" });
Assert.All(spans, span => Assert.True(span.IsFinished));
}
[SkippableFact]
public void EfCoreIntegration_RunSynchronousQuery_TransactionWithSpans()
{
Skip.If(RuntimeInfo.GetRuntime().IsMono());
// Arrange
var hub = _fixture.Hub;
var transaction = hub.StartTransaction("test", "test");
var spans = transaction.Spans;
var context = _fixture.NewContext();
// Act
var result = context.Items.FromSqlRaw("SELECT * FROM Items").ToList();
// Assert
Assert.Equal(3, result.Count);
#if NETFRAMEWORK
Assert.Single(spans); //1 command
#else
Assert.Equal(2, spans.Count); //1 query compiler, 1 command
#endif
Assert.All(spans, span => Assert.True(span.IsFinished));
}
[SkippableFact]
public async Task EfCoreIntegration_RunAsyncQuery_TransactionWithSpansWithOneCompiler()
{
Skip.If(RuntimeInfo.GetRuntime().IsMono());
// Arrange
var context = _fixture.NewContext();
var commands = new List<int>();
var totalCommands = 50;
for (var j = 0; j < totalCommands; j++)
{
var i = j + 4;
context.Items.Add(new Item { Name = $"Number {i}" });
context.Items.Add(new Item { Name = $"Number2 {i}" });
context.Items.Add(new Item { Name = $"Number3 {i}" });
commands.Add(i * 2);
}
// Save before the Transaction creation to avoid storing junk.
//Dont async here since it will fail in mac+linux with
// The type initializer for 'System.Data.Common.DbConnectionExtensions' threw an exception.
// Expression of type 'ValueTask[System.Data.Common.DbTransaction]' cannot be used...
// ReSharper disable once MethodHasAsyncOverload
context.SaveChanges();
var hub = _fixture.Hub;
var transaction = hub.StartTransaction("test", "test");
var spans = transaction.Spans;
var itemsList = new ConcurrentBag<List<Item>>();
// Act
var tasks = commands.Select(async limit =>
{
var command = $"SELECT * FROM Items LIMIT {limit}";
itemsList.Add(await _fixture.NewContext().Items.FromSqlRaw(command).ToListAsync());
});
await Task.WhenAll(tasks);
// Assert
Assert.Equal(totalCommands, itemsList.Count);
Assert.Equal(totalCommands, spans.Count(s => s.Operation == "db.query"));
#if NET5_0_OR_GREATER
Assert.Equal(totalCommands, spans.Count(s => s.Operation == "db.query.compile"));
#endif
Assert.All(spans, span =>
{
Assert.True(span.IsFinished);
Assert.Equal(SpanStatus.Ok, span.Status);
Assert.Equal(transaction.SpanId, span.ParentSpanId);
});
}
[SkippableFact]
public async Task EfCoreIntegration_RunAsyncQuery_TransactionWithSpans()
{
Skip.If(RuntimeInfo.GetRuntime().IsMono());
// Arrange
var context = _fixture.NewContext();
var hub = _fixture.Hub;
var transaction = hub.StartTransaction("test", "test");
var spans = transaction.Spans;
// Act
var result = new[]
{
context.Items.FromSqlRaw("SELECT * FROM Items WHERE 1=1 LIMIT 10").ToListAsync(),
context.Items.FromSqlRaw("SELECT * FROM Items WHERE 1=1 LIMIT 9").ToListAsync(),
context.Items.FromSqlRaw("SELECT * FROM Items WHERE 1=1 LIMIT 8").ToListAsync(),
context.Items.FromSqlRaw("SELECT * FROM Items WHERE 1=1 LIMIT 7").ToListAsync(),
};
await Task.WhenAll(result);
// Assert
Assert.Equal(3, result[0].Result.Count);
Assert.Equal(4, spans.Count(s => s.Operation == "db.query"));
#if NET5_0_OR_GREATER
Assert.Equal(4, spans.Count(s => s.Operation == "db.query.compile"));
#endif
Assert.All(spans, span =>
{
Assert.True(span.IsFinished);
Assert.Equal(SpanStatus.Ok, span.Status);
Assert.Equal(transaction.SpanId, span.ParentSpanId);
});
}
}
| Fixture |
csharp | dotnet__maui | src/Controls/tests/Xaml.UnitTests/Issues/Maui25819.xaml.cs | {
"start": 294,
"end": 389
} | public partial class ____ : ContentPage
{
public Maui25819() => InitializeComponent();
| Maui25819 |
csharp | ChilliCream__graphql-platform | src/Nitro/CommandLine/src/CommandLine.Cloud/Generated/ApiClient.Client.cs | {
"start": 1061496,
"end": 1063336
} | public partial class ____ : global::System.IEquatable<ListWorkspaceCommandQueryResult>, IListWorkspaceCommandQueryResult
{
public ListWorkspaceCommandQueryResult(global::ChilliCream.Nitro.CommandLine.Cloud.Client.IListWorkspaceCommandQuery_Me? me)
{
Me = me;
}
public global::ChilliCream.Nitro.CommandLine.Cloud.Client.IListWorkspaceCommandQuery_Me? Me { get; }
public virtual global::System.Boolean Equals(ListWorkspaceCommandQueryResult? other)
{
if (ReferenceEquals(null, other))
{
return false;
}
if (ReferenceEquals(this, other))
{
return true;
}
if (other.GetType() != GetType())
{
return false;
}
return (((Me is null && other.Me is null) || Me != null && Me.Equals(other.Me)));
}
public override global::System.Boolean Equals(global::System.Object? obj)
{
if (ReferenceEquals(null, obj))
{
return false;
}
if (ReferenceEquals(this, obj))
{
return true;
}
if (obj.GetType() != GetType())
{
return false;
}
return Equals((ListWorkspaceCommandQueryResult)obj);
}
public override global::System.Int32 GetHashCode()
{
unchecked
{
int hash = 5;
if (Me != null)
{
hash ^= 397 * Me.GetHashCode();
}
return hash;
}
}
}
[global::System.CodeDom.Compiler.GeneratedCode("StrawberryShake", "15.1.8.0")]
| ListWorkspaceCommandQueryResult |
csharp | dotnet__orleans | test/Orleans.Serialization.UnitTests/BuiltInCodecTests.cs | {
"start": 37562,
"end": 38232
} | public class ____(ITestOutputHelper output) : CopierTester<ValueTuple<string, string>, ValueTupleCopier<string, string>>(output)
{
protected override ValueTuple<string, string> CreateValue() => ValueTuple.Create(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
protected override ValueTuple<string, string>[] TestValues =>
[
default,
ValueTuple.Create<string, string>(null, null),
ValueTuple.Create<string, string>(string.Empty, "foo"),
ValueTuple.Create<string, string>("foo", "bar"),
ValueTuple.Create<string, string>("foo", "foo"),
];
}
| ValueTuple2CopierTests |
csharp | DuendeSoftware__IdentityServer | identity-server/test/IdentityServer.UnitTests/Extensions/HttpContextExtensionsTests.cs | {
"start": 557,
"end": 9205
} | public class ____
{
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_without_logout_message_returns_null_if_no_clients_have_front_channel_logout_uri()
{
var clientWithoutFrontChannelLogoutUrl = new Client
{
ClientId = "client_without_frontchannel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" }
};
var context = CreateContextWithUserSession("Test", clientWithoutFrontChannelLogoutUrl);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync();
result.ShouldBeNull();
}
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_without_logout_message_returns_url_if_single_client_has_front_channel_logout_uri()
{
var clientWithFrontChannelLogoutUrl = new Client
{
ClientId = "client_with_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" },
FrontChannelLogoutUri = "http://foo"
};
var clientWithoutFrontChannelLogoutUrl = new Client
{
ClientId = "client_without_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" }
};
var context = CreateContextWithUserSession("Test", clientWithoutFrontChannelLogoutUrl, clientWithFrontChannelLogoutUrl);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync();
result.ShouldStartWith("/connect/endsession/callback?endSessionId=");
}
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_without_logout_message_returns_url_if_multiple_clients_have_front_channel_logout_uri()
{
var firstClientWithFrontChannelLogoutUrl = new Client
{
ClientId = "first_client_with_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" },
FrontChannelLogoutUri = "http://foo"
};
var secondClientWithFrontChannelLogoutUrl = new Client
{
ClientId = "second_client_with_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" },
FrontChannelLogoutUri = "http://bar"
};
var clientWithoutFrontChannelLogoutUrl = new Client
{
ClientId = "client_without_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" }
};
var context = CreateContextWithUserSession("Test", firstClientWithFrontChannelLogoutUrl,
secondClientWithFrontChannelLogoutUrl, clientWithoutFrontChannelLogoutUrl);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync();
result.ShouldStartWith("/connect/endsession/callback?endSessionId=");
}
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_with_logout_message_returns_url_if_logout_message_has_client_with_front_channel_logout_uri()
{
var clientWithFrontChannelLogoutUrl = new Client
{
ClientId = "client_with_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" },
FrontChannelLogoutUri = "http://foo"
};
var clientWithoutFrontChannelLogoutUrl = new Client
{
ClientId = "client_without_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" }
};
var logoutMessage = new LogoutMessage
{
SubjectId = "Test",
SessionId = "session-id",
ClientIds = [clientWithFrontChannelLogoutUrl.ClientId]
};
var context = CreateContextWithUserSession("Test", clientWithoutFrontChannelLogoutUrl, clientWithFrontChannelLogoutUrl);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync(logoutMessage);
result.ShouldStartWith("/connect/endsession/callback?endSessionId=");
}
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_with_logout_message_returns_null_if_logout_message_has_no_client_with_front_channel_logout_uri()
{
var clientWithoutFrontChannelLogoutUrl = new Client
{
ClientId = "client_without_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" }
};
var logoutMessage = new LogoutMessage
{
SubjectId = "Test",
SessionId = "session-id",
ClientIds = [clientWithoutFrontChannelLogoutUrl.ClientId]
};
var context = CreateContextWithUserSession("Test", clientWithoutFrontChannelLogoutUrl);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync(logoutMessage);
result.ShouldBeNull();
}
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_with_logout_message_returns_url_if_logout_message_has_no_clients_but_user_session_has_client_with_front_channel_logout_url()
{
var logoutMessage = new LogoutMessage
{
SubjectId = "Test",
SessionId = "session-id",
ClientIds = []
};
var clientWithFrontChannelLogoutUrl = new Client
{
ClientId = "client_with_front_channel_logout_url",
AllowedGrantTypes = GrantTypes.ClientCredentials,
RequireClientSecret = false,
AllowedScopes = { "api1" },
FrontChannelLogoutUri = "http://foo"
};
var context = CreateContextWithUserSession("Test", clientWithFrontChannelLogoutUrl);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync(logoutMessage);
result.ShouldStartWith("/connect/endsession/callback?endSessionId=");
}
[Fact]
public async Task GetIdentityServerSignoutFrameCallbackUrlAsync_with_logout_message_returns_null_if_logout_message_has_no_clients_and_user_session_has_no_clients()
{
var logoutMessage = new LogoutMessage
{
SubjectId = "Test",
SessionId = "session-id",
ClientIds = []
};
var context = CreateContextWithUserSession("Test");
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync(logoutMessage);
result.ShouldBeNull();
}
[Fact]
public async Task
GetIdentityServerSignoutFrameCallbackUrlAsync_with_logout_message_returns_null_when_logout_message_has_no_clients_and_user_session_has_no_subject_id()
{
var logoutMessage = new LogoutMessage
{
SubjectId = "Test",
SessionId = "session-id",
ClientIds = []
};
var context = CreateContextWithUserSession(null);
var result = await context.GetIdentityServerSignoutFrameCallbackUrlAsync(logoutMessage);
result.ShouldBeNull();
}
private DefaultHttpContext CreateContextWithUserSession(string? subjectId, params Client[] clients)
{
var userSession = new MockUserSession
{
Clients = clients.Select(client => client.ClientId).ToList(),
};
if (subjectId != null)
{
userSession.User = new ClaimsPrincipal(new ClaimsIdentity([new Claim(JwtClaimTypes.Subject, subjectId)]));
}
var clientStore = new InMemoryClientStore(clients);
var services = new ServiceCollection();
services.AddSingleton<IUserSession>(userSession);
services.AddSingleton<IClientStore>(clientStore);
services.AddSingleton<IClock>(new MockClock());
services.AddSingleton<IMessageStore<LogoutNotificationContext>, MockMessageStore<LogoutNotificationContext>>();
services.AddSingleton<IServerUrls>(new MockServerUrls());
return new DefaultHttpContext
{
RequestServices = services.BuildServiceProvider()
};
}
}
| HttpContextExtensionsTests |
csharp | louthy__language-ext | LanguageExt.Core/Immutable Collections/Map/Map.Internal.cs | {
"start": 53046,
"end": 56500
} | public enum ____
{
ThrowOnDuplicate,
TryAdd,
TryUpdate
}
public static MapItem<K, V> Add<OrdK, K, V>(MapItem<K, V> node, K key, V value, AddOpt option)
where OrdK : Ord<K>
{
if (node.IsEmpty)
{
return new MapItem<K, V>(1, 1, (key, value), MapItem<K, V>.Empty, MapItem<K, V>.Empty);
}
var cmp = OrdK.Compare(key, node.KeyValue.Key);
if (cmp < 0)
{
node.Left = Add<OrdK, K, V>(node.Left, key, value, option);
return Balance(node);
}
else if (cmp > 0)
{
node.Right = Add<OrdK, K, V>(node.Right, key, value, option);
return Balance(node);
}
else if(option == AddOpt.TryAdd)
{
// Already exists, but we don't care
return node;
}
else if (option == AddOpt.TryUpdate)
{
// Already exists, and we want to update the content
node.KeyValue = (key, value);
return node;
}
else
{
throw new ArgumentException("An element with the same key already exists in the Map");
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MapItem<K, V> Balance<K, V>(MapItem<K, V> node)
{
node.Height = (byte)(1 + Math.Max(node.Left.Height, node.Right.Height));
node.Count = 1 + node.Left.Count + node.Right.Count;
return node.BalanceFactor >= 2
? node.Right.BalanceFactor < 0
? DblRotLeft(node)
: RotLeft(node)
: node.BalanceFactor <= -2
? node.Left.BalanceFactor > 0
? DblRotRight(node)
: RotRight(node)
: node;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MapItem<K, V> DblRotRight<K, V>(MapItem<K, V> node)
{
node.Left = RotLeft(node.Left);
return RotRight(node);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MapItem<K, V> DblRotLeft<K, V>(MapItem<K, V> node)
{
node.Right = RotRight(node.Right);
return RotLeft(node);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MapItem<K, V> RotRight<K, V>(MapItem<K, V> node)
{
if (node.IsEmpty || node.Left.IsEmpty) return node;
var y = node;
var x = y.Left;
var t2 = x.Right;
x.Right = y;
y.Left = t2;
y.Height = (byte)(1 + Math.Max(y.Left.Height, y.Right.Height));
x.Height = (byte)(1 + Math.Max(x.Left.Height, x.Right.Height));
y.Count = 1 + y.Left.Count + y.Right.Count;
x.Count = 1 + x.Left.Count + x.Right.Count;
return x;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static MapItem<K, V> RotLeft<K, V>(MapItem<K, V> node)
{
if (node.IsEmpty || node.Right.IsEmpty) return node;
var x = node;
var y = x.Right;
var t2 = y.Left;
y.Left = x;
x.Right = t2;
x.Height = (byte)(1 + Math.Max(x.Left.Height, x.Right.Height));
y.Height = (byte)(1 + Math.Max(y.Left.Height, y.Right.Height));
x.Count = 1 + x.Left.Count + x.Right.Count;
y.Count = 1 + y.Left.Count + y.Right.Count;
return y;
}
}
| AddOpt |
csharp | unoplatform__uno | src/Uno.UI/Generated/3.0.0.0/Microsoft.UI.Xaml.Input/KeyboardNavigationMode.cs | {
"start": 221,
"end": 540
} | public enum ____
{
// Skipping already declared field Microsoft.UI.Xaml.Input.KeyboardNavigationMode.Local
// Skipping already declared field Microsoft.UI.Xaml.Input.KeyboardNavigationMode.Cycle
// Skipping already declared field Microsoft.UI.Xaml.Input.KeyboardNavigationMode.Once
}
#endif
}
| KeyboardNavigationMode |
csharp | getsentry__sentry-dotnet | src/Sentry.Android.AssemblyReader/V2/AssemblyStoreExplorer.cs | {
"start": 362,
"end": 4713
} | internal class ____
{
private readonly AssemblyStoreReader _reader;
public AndroidTargetArch? TargetArch { get; }
public IList<AssemblyStoreItem>? Assemblies { get; }
public IDictionary<string, AssemblyStoreItem>? AssembliesByName { get; }
public bool Is64Bit { get; }
private AssemblyStoreExplorer(Stream storeStream, string path, DebugLogger? logger)
{
var storeReader = AssemblyStoreReader.Create(storeStream, path, logger);
if (storeReader == null)
{
storeStream.Dispose();
throw new NotSupportedException($"Format of assembly store '{path}' is unsupported");
}
_reader = storeReader;
TargetArch = _reader.TargetArch;
Assemblies = _reader.Assemblies;
Is64Bit = _reader.Is64Bit;
var dict = new Dictionary<string, AssemblyStoreItem>(StringComparer.Ordinal);
if (Assemblies is not null)
{
foreach (var item in Assemblies)
{
logger?.Invoke(DebugLoggerLevel.Debug, "Assembly {0} indexed from AssemblyStore {1}", item.Name, path);
dict.Add(item.Name, item);
}
}
AssembliesByName = dict.AsReadOnly();
}
private AssemblyStoreExplorer(FileInfo storeInfo, DebugLogger? logger)
: this(storeInfo.OpenRead(), storeInfo.FullName, logger)
{ }
public static (IList<AssemblyStoreExplorer>? explorers, string? errorMessage) Open(string inputFile, DebugLogger? logger)
{
var (format, info) = Utils.DetectFileFormat(inputFile);
if (info == null)
{
return (null, $"File '{inputFile}' does not exist.");
}
switch (format)
{
case FileFormat.Unknown:
return (null, $"File '{inputFile}' has an unknown format.");
case FileFormat.Zip:
return (null, $"File '{inputFile}' is a ZIP archive, but not an Android one.");
case FileFormat.AssemblyStore:
case FileFormat.ELF:
return (new List<AssemblyStoreExplorer> { new AssemblyStoreExplorer(info, logger) }, null);
case FileFormat.Aab:
return OpenAab(info, logger);
case FileFormat.AabBase:
return OpenAabBase(info, logger);
case FileFormat.Apk:
return OpenApk(info, logger);
default:
return (null, $"File '{inputFile}' has an unsupported format '{format}'");
}
}
private static (IList<AssemblyStoreExplorer>? explorers, string? errorMessage) OpenAab(FileInfo fi, DebugLogger? logger)
=> OpenCommon(fi, StoreReader.AabPaths, logger);
private static (IList<AssemblyStoreExplorer>? explorers, string? errorMessage) OpenAabBase(FileInfo fi, DebugLogger? logger)
=> OpenCommon(fi, StoreReader.AabBasePaths, logger);
private static (IList<AssemblyStoreExplorer>? explorers, string? errorMessage) OpenApk(FileInfo fi, DebugLogger? logger)
=> OpenCommon(fi, StoreReader.ApkPaths, logger);
private static (IList<AssemblyStoreExplorer>? explorers, string? errorMessage) OpenCommon(FileInfo fi, IList<string> paths, DebugLogger? logger)
{
using var zip = ZipFile.OpenRead(fi.FullName);
var (explorers, errorMessage, pathsFound) = TryLoad(fi, zip, paths, logger);
return pathsFound ? (explorers, errorMessage) : (null, "Unable to find any blob entries");
}
private static (IList<AssemblyStoreExplorer>? explorers, string? errorMessage, bool pathsFound) TryLoad(FileInfo fi, ZipArchive zip, IList<string> paths, DebugLogger? logger)
{
var ret = new List<AssemblyStoreExplorer>();
foreach (var path in paths)
{
if (zip.GetEntry(path) is not { } entry)
{
continue;
}
var stream = entry.Extract();
ret.Add(new AssemblyStoreExplorer(stream, $"{fi.FullName}!{path}", logger));
}
if (ret.Count == 0)
{
return (null, null, false);
}
return (ret, null, true);
}
public MemoryStream? ReadImageData(AssemblyStoreItem item, bool uncompressIfNeeded = false)
{
return _reader.ReadEntryImageData(item, uncompressIfNeeded);
}
}
| AssemblyStoreExplorer |
csharp | ChilliCream__graphql-platform | src/Nitro/CommandLine/src/CommandLine.Cloud/Generated/ApiClient.Client.cs | {
"start": 910882,
"end": 911145
} | public partial interface ____ : IUnpublishClient_UnpublishClient_Errors, IClientVersionNotFoundError
{
}
[global::System.CodeDom.Compiler.GeneratedCode("StrawberryShake", "15.1.8.0")]
| IUnpublishClient_UnpublishClient_Errors_ClientVersionNotFoundError |
csharp | dotnet__aspnetcore | src/Mvc/test/Mvc.IntegrationTests/ComplexTypeIntegrationTestBase.cs | {
"start": 128848,
"end": 130574
} | private class ____
{
[ModelBinder(typeof(SuccessfulModelBinder))]
public bool IsBound { get; set; }
public ThreeDeepModel Inner { get; set; }
}
// Ensure model binding system disallows one more than MaxModelBindingRecursionDepth binders on the stack.
[Fact]
public async Task ModelBindingSystem_ThrowsOn4Binders()
{
// Arrange
var expectedMessage = $"Model binding system exceeded " +
$"{nameof(MvcOptions)}.{nameof(MvcOptions.MaxModelBindingRecursionDepth)} (3). Reduce the " +
$"potential nesting of '{typeof(FourDeepModel)}'. For example, this type may have a property with a " +
$"model binder that always succeeds. See the " +
$"{nameof(MvcOptions)}.{nameof(MvcOptions.MaxModelBindingRecursionDepth)} documentation for more " +
$"information.";
var parameter = new ParameterDescriptor()
{
Name = "parameter",
ParameterType = typeof(FourDeepModel),
};
var testContext = GetTestContext(
updateOptions: options => options.MaxModelBindingRecursionDepth = 3);
var modelState = testContext.ModelState;
var metadata = testContext.MetadataProvider.GetMetadataForType(parameter.ParameterType);
var valueProvider = await CompositeValueProvider.CreateAsync(testContext);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testContext);
// Act & Assert
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
() => parameterBinder.BindModelAsync(parameter, testContext));
Assert.Equal(expectedMessage, exception.Message);
}
| FourDeepModel |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Language/src/Language.Web/Sha1DocumentHashProvider.cs | {
"start": 139,
"end": 1114
} | public sealed class ____ : DocumentHashProviderBase
{
private readonly ThreadLocal<SHA1> _sha = new(SHA1.Create);
public Sha1DocumentHashProvider()
: this(HashFormat.Base64)
{
}
public Sha1DocumentHashProvider(HashFormat format)
: base(format)
{
}
public override string Name => "sha1Hash";
#if NETSTANDARD2_0
protected override byte[] ComputeHash(byte[] document, int length)
=> _sha.Value!.ComputeHash(document, 0, length);
#else
[MethodImpl(MethodImplOptions.AggressiveInlining)]
protected override string ComputeHash(ReadOnlySpan<byte> document, HashFormat format)
{
var hashBytes = new byte[20];
var hashSpan = hashBytes.AsSpan();
_sha.Value!.TryComputeHash(document, hashBytes, out var written);
if (written < 20)
{
hashSpan = hashSpan[..written];
}
return FormatHash(hashSpan, format);
}
#endif
}
| Sha1DocumentHashProvider |
csharp | MonoGame__MonoGame | Tools/MonoGame.Effect.Compiler/Effect/EffectObject.cs | {
"start": 5053,
"end": 5589
} | public enum ____
{
VIEW = 2,
PROJECTION = 3,
TEXTURE0 = 16,
TEXTURE1 = 17,
TEXTURE2 = 18,
TEXTURE3 = 19,
TEXTURE4 = 20,
TEXTURE5 = 21,
TEXTURE6 = 22,
TEXTURE7 = 23,
WORLD = 256,
FORCE_DWORD = 0x7fffffff
}
public const int D3DX_PARAMETER_SHARED = 1;
public const int D3DX_PARAMETER_LITERAL = 2;
public const int D3DX_PARAMETER_ANNOTATION = 4;
| D3DTRANSFORMSTATETYPE |
csharp | smartstore__Smartstore | src/Smartstore/Caching/ScopedServiceBase.cs | {
"start": 87,
"end": 1307
} | public abstract class ____ : IScopedService
{
/// <inheritdoc/>
public IDisposable BeginScope(bool clearCache = true)
{
if (IsInScope)
{
// nested batches are not supported
return ActionDisposable.Empty;
}
OnBeginScope();
IsInScope = true;
return new ActionDisposable(() =>
{
IsInScope = false;
OnEndScope();
if (clearCache && HasChanges)
{
ClearCache();
}
});
}
/// <inheritdoc/>
public bool HasChanges
{
get;
protected set;
}
protected bool IsInScope
{
get;
private set;
}
/// <inheritdoc/>
public void ClearCache()
{
if (!IsInScope)
{
OnClearCache();
HasChanges = false;
}
}
protected abstract void OnClearCache();
protected virtual void OnBeginScope() { }
protected virtual void OnEndScope() { }
}
}
| ScopedServiceBase |
csharp | ServiceStack__ServiceStack | ServiceStack/src/ServiceStack.Common/ViewUtils.cs | {
"start": 5429,
"end": 7465
} | public class ____
{
public string Id { get; set; }
public string ClassName { get; set; }
public string ChildClass { get; set; }
public TextStyle HeaderStyle { get; set; }
public string HeaderTag { get; set; }
public string Caption { get; set; }
public string CaptionIfEmpty { get; set; }
public string[] Headers { get; set; }
public DefaultScripts Defaults { get; set; } = ViewUtils.DefaultScripts;
public string Display { get; set; }
internal int Depth { get; set; }
internal int ChildDepth { get; set; } = 1;
internal bool HasCaption { get; set; }
public static HtmlDumpOptions Parse(Dictionary<string, object> options, DefaultScripts defaults=null)
{
return new HtmlDumpOptions
{
Id = options.TryGetValue("id", out var oId)
? (string)oId
: null,
ClassName = options.TryGetValue("className", out var oClassName)
? (string)oClassName
: null,
ChildClass = options.TryGetValue("childClass", out var oChildClass)
? (string)oChildClass
: null,
HeaderStyle = options.TryGetValue("headerStyle", out var oHeaderStyle)
? oHeaderStyle.ConvertTo<TextStyle>()
: TextStyle.SplitCase,
HeaderTag = options.TryGetValue("headerTag", out var oHeaderTag)
? (string)oHeaderTag
: null,
Caption = options.TryGetValue("caption", out var caption)
? caption?.ToString()
: null,
CaptionIfEmpty = options.TryGetValue("captionIfEmpty", out var captionIfEmpty)
? captionIfEmpty?.ToString()
: null,
Display = options.TryGetValue("display", out var display)
? display?.ToString()
: null,
Defaults = defaults ?? ViewUtils.DefaultScripts,
};
}
}
| HtmlDumpOptions |
csharp | LibreHardwareMonitor__LibreHardwareMonitor | LibreHardwareMonitorLib/Hardware/Motherboard/Lpc/Chip.cs | {
"start": 524,
"end": 2254
} | internal enum ____ : ushort
{
Unknown = 0,
ATK0110 = 0x0110,
F71808E = 0x0901,
F71811 = 0x1007,
F71858 = 0x0507,
F71862 = 0x0601,
F71869 = 0x0814,
F71869A = 0x1007,
F71878AD = 0x1106,
F71882 = 0x0541,
F71889AD = 0x1005,
F71889ED = 0x0909,
F71889F = 0x0723,
IT8613E = 0x8613,
IT8620E = 0x8620,
IT8625E = 0x8625,
IT8628E = 0x8628,
IT8631E = 0x8631,
IT8638E = 0x8638,
IT8655E = 0x8655,
IT8665E = 0x8665,
IT8686E = 0x8686,
IT8688E = 0x8688,
IT8689E = 0x8689,
IT8696E = 0x8696,
IT8705F = 0x8705,
IT8712F = 0x8712,
IT8716F = 0x8716,
IT8718F = 0x8718,
IT8720F = 0x8720,
IT8721F = 0x8721,
IT8726F = 0x8726,
IT8728F = 0x8728,
IT8771E = 0x8771,
IT8772E = 0x8772,
IT8790E = 0x8790,
IT8792E = 0x8733, // Could also be IT8791E, IT8795E
IT87952E = 0x8695,
NCT5585D = 0xFFF0, // Chip reports 0xD42A but that's in use
NCT610XD = 0xC452,
NCT6771F = 0xB470,
NCT6776F = 0xC330,
NCT6779D = 0xC560,
NCT6791D = 0xC803,
NCT6792D = 0xC911,
NCT6792DA = 0xC913,
NCT6793D = 0xD121,
NCT6795D = 0xD352,
NCT6796D = 0xD423,
NCT6796DR = 0xD42A,
NCT6796DS = 0xFFF1, // Chip reports 0xD802 but that's in use
NCT6797D = 0xD451,
NCT6798D = 0xD42B,
NCT6686D = 0xD440,
NCT6687D = 0xD592,
NCT6687DR = 0xFFFF, // Dummy Entry for MSI AM5/LGA1851 Motherboards
NCT6683D = 0xC732,
NCT6799D = 0xD802,
NCT6701D = 0xD806,
W83627DHG = 0xA020,
W83627DHGP = 0xB070,
W83627EHF = 0x8800,
W83627HF = 0x5200,
W83627THF = 0x8280,
W83667HG = 0xA510,
W83667HGB = 0xB350,
W83687THF = 0x8541,
IPMI = 0x4764,
}
| Chip |
csharp | EventStore__EventStore | src/KurrentDB.Core.Tests/AwakeService/when_handling_comitted_event.cs | {
"start": 474,
"end": 1685
} | public class ____<TLogFormat, TStreamId> {
private KurrentDB.Core.Services.AwakeReaderService.AwakeService _it;
private EventRecord _eventRecord;
private StorageMessage.EventCommitted _eventCommitted;
private Exception _exception;
[SetUp]
public void SetUp() {
_exception = null;
Given();
When();
}
private void Given() {
_it = new KurrentDB.Core.Services.AwakeReaderService.AwakeService();
var recordFactory = LogFormatHelper<TLogFormat, TStreamId>.RecordFactory;
var streamId = LogFormatHelper<TLogFormat, TStreamId>.StreamId;
var eventTypeId = LogFormatHelper<TLogFormat, TStreamId>.EventTypeId;
_eventRecord = new EventRecord(
10,
LogRecord.Prepare(
recordFactory, 500, Guid.NewGuid(), Guid.NewGuid(), 500, 0, streamId, 99, PrepareFlags.Data,
eventTypeId, new byte[0], null, DateTime.UtcNow), "Stream", "EventType");
_eventCommitted = new StorageMessage.EventCommitted(1000, _eventRecord, isTfEof: true);
}
private void When() {
try {
_it.Handle(_eventCommitted);
} catch (Exception ex) {
_exception = ex;
}
}
[Test]
public void it_is_handled() {
Assert.IsNull(_exception, (_exception ?? (object)"").ToString());
}
}
| when_handling_comitted_event |
csharp | ChilliCream__graphql-platform | src/StrawberryShake/Client/src/Core/IOperationExecutor.cs | {
"start": 236,
"end": 1312
} | public interface ____<TResultData> where TResultData : class
{
/// <summary>
/// Executes the result and returns the result.
/// </summary>
/// <param name="request">
/// The operation request.
/// </param>
/// <param name="cancellationToken">
/// The cancellation token.
/// </param>
/// <returns>
/// Returns the operation result.
/// </returns>
Task<IOperationResult<TResultData>> ExecuteAsync(
OperationRequest request,
CancellationToken cancellationToken = default);
/// <summary>
/// Registers a requests and subscribes to updates on the request results.
/// </summary>
/// <param name="request">
/// The operation request.
/// </param>
/// <param name="strategy">
/// The request execution strategy.
/// </param>
/// <returns>
/// The observable that can be used to subscribe to results.
/// </returns>
IObservable<IOperationResult<TResultData>> Watch(
OperationRequest request,
ExecutionStrategy? strategy = null);
}
| IOperationExecutor |
csharp | npgsql__npgsql | src/Npgsql/Internal/Converters/Primitive/TextConverters.cs | {
"start": 5446,
"end": 6781
} | sealed class ____(Encoding encoding) : PgBufferedConverter<char>
{
readonly Size _oneCharMaxByteCount = Size.CreateUpperBound(encoding.GetMaxByteCount(1));
public override bool CanConvert(DataFormat format, out BufferRequirements bufferRequirements)
{
bufferRequirements = BufferRequirements.Create(_oneCharMaxByteCount);
return format is DataFormat.Binary or DataFormat.Text;
}
protected override char ReadCore(PgReader reader)
{
var byteSeq = reader.ReadBytes(Math.Min(_oneCharMaxByteCount.Value, reader.CurrentRemaining));
Debug.Assert(byteSeq.IsSingleSegment);
var bytes = byteSeq.FirstSpan;
var chars = encoding.GetCharCount(bytes);
if (chars < 1)
throw new NpgsqlException("Could not read char - string was empty");
Span<char> destination = stackalloc char[chars];
encoding.GetChars(bytes, destination);
return destination[0];
}
public override Size GetSize(SizeContext context, char value, ref object? writeState)
{
Span<char> spanValue = [value];
return encoding.GetByteCount(spanValue);
}
protected override void WriteCore(PgWriter writer, char value)
{
Span<char> spanValue = [value];
writer.WriteChars(spanValue, encoding);
}
}
| CharTextConverter |
csharp | StackExchange__StackExchange.Redis | src/StackExchange.Redis/FastHash.cs | {
"start": 854,
"end": 5523
} | internal static class ____
{
/* not sure we need this, but: retain for reference
// Perform case-insensitive hash by masking (X and x differ by only 1 bit); this halves
// our entropy, but is still useful when case doesn't matter.
private const long CaseMask = ~0x2020202020202020;
public static long Hash64CI(this ReadOnlySequence<byte> value)
=> value.Hash64() & CaseMask;
public static long Hash64CI(this scoped ReadOnlySpan<byte> value)
=> value.Hash64() & CaseMask;
*/
public static long Hash64(this ReadOnlySequence<byte> value)
{
#if NETCOREAPP3_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
var first = value.FirstSpan;
#else
var first = value.First.Span;
#endif
return first.Length >= sizeof(long) || value.IsSingleSegment
? first.Hash64() : SlowHash64(value);
static long SlowHash64(ReadOnlySequence<byte> value)
{
Span<byte> buffer = stackalloc byte[sizeof(long)];
if (value.Length < sizeof(long))
{
value.CopyTo(buffer);
buffer.Slice((int)value.Length).Clear();
}
else
{
value.Slice(0, sizeof(long)).CopyTo(buffer);
}
return BitConverter.IsLittleEndian
? Unsafe.ReadUnaligned<long>(ref MemoryMarshal.GetReference(buffer))
: BinaryPrimitives.ReadInt64LittleEndian(buffer);
}
}
public static long Hash64(this scoped ReadOnlySpan<byte> value)
{
if (BitConverter.IsLittleEndian)
{
ref byte data = ref MemoryMarshal.GetReference(value);
return value.Length switch
{
0 => 0,
1 => data, // 0000000A
2 => Unsafe.ReadUnaligned<ushort>(ref data), // 000000BA
3 => Unsafe.ReadUnaligned<ushort>(ref data) | // 000000BA
(Unsafe.Add(ref data, 2) << 16), // 00000C00
4 => Unsafe.ReadUnaligned<uint>(ref data), // 0000DCBA
5 => Unsafe.ReadUnaligned<uint>(ref data) | // 0000DCBA
((long)Unsafe.Add(ref data, 4) << 32), // 000E0000
6 => Unsafe.ReadUnaligned<uint>(ref data) | // 0000DCBA
((long)Unsafe.ReadUnaligned<ushort>(ref Unsafe.Add(ref data, 4)) << 32), // 00FE0000
7 => Unsafe.ReadUnaligned<uint>(ref data) | // 0000DCBA
((long)Unsafe.ReadUnaligned<ushort>(ref Unsafe.Add(ref data, 4)) << 32) | // 00FE0000
((long)Unsafe.Add(ref data, 6) << 48), // 0G000000
_ => Unsafe.ReadUnaligned<long>(ref data), // HGFEDCBA
};
}
#pragma warning disable CS0618 // Type or member is obsolete
return Hash64Fallback(value);
#pragma warning restore CS0618 // Type or member is obsolete
}
[Obsolete("Only exists for benchmarks (to show that we don't need to use it) and unit tests (for correctness)")]
internal static unsafe long Hash64Unsafe(scoped ReadOnlySpan<byte> value)
{
if (BitConverter.IsLittleEndian)
{
fixed (byte* ptr = &MemoryMarshal.GetReference(value))
{
return value.Length switch
{
0 => 0,
1 => *ptr, // 0000000A
2 => *(ushort*)ptr, // 000000BA
3 => *(ushort*)ptr | // 000000BA
(ptr[2] << 16), // 00000C00
4 => *(int*)ptr, // 0000DCBA
5 => (long)*(int*)ptr | // 0000DCBA
((long)ptr[4] << 32), // 000E0000
6 => (long)*(int*)ptr | // 0000DCBA
((long)*(ushort*)(ptr + 4) << 32), // 00FE0000
7 => (long)*(int*)ptr | // 0000DCBA
((long)*(ushort*)(ptr + 4) << 32) | // 00FE0000
((long)ptr[6] << 48), // 0G000000
_ => *(long*)ptr, // HGFEDCBA
};
}
}
return Hash64Fallback(value);
}
[Obsolete("Only exists for unit tests and fallback")]
internal static long Hash64Fallback(scoped ReadOnlySpan<byte> value)
{
if (value.Length < sizeof(long))
{
Span<byte> tmp = stackalloc byte[sizeof(long)];
value.CopyTo(tmp); // ABC*****
tmp.Slice(value.Length).Clear(); // ABC00000
return BinaryPrimitives.ReadInt64LittleEndian(tmp); // 00000CBA
}
return BinaryPrimitives.ReadInt64LittleEndian(value); // HGFEDCBA
}
}
| FastHash |
csharp | bitwarden__server | src/Core/AdminConsole/OrganizationFeatures/Organizations/OrganizationDeleteCommand.cs | {
"start": 326,
"end": 2236
} | public class ____ : IOrganizationDeleteCommand
{
private readonly IApplicationCacheService _applicationCacheService;
private readonly IOrganizationRepository _organizationRepository;
private readonly IPaymentService _paymentService;
private readonly ISsoConfigRepository _ssoConfigRepository;
public OrganizationDeleteCommand(
IApplicationCacheService applicationCacheService,
IOrganizationRepository organizationRepository,
IPaymentService paymentService,
ISsoConfigRepository ssoConfigRepository)
{
_applicationCacheService = applicationCacheService;
_organizationRepository = organizationRepository;
_paymentService = paymentService;
_ssoConfigRepository = ssoConfigRepository;
}
public async Task DeleteAsync(Organization organization)
{
await ValidateDeleteOrganizationAsync(organization);
if (!string.IsNullOrWhiteSpace(organization.GatewaySubscriptionId))
{
try
{
var eop = !organization.ExpirationDate.HasValue ||
organization.ExpirationDate.Value >= DateTime.UtcNow;
await _paymentService.CancelSubscriptionAsync(organization, eop);
}
catch (GatewayException) { }
}
await _organizationRepository.DeleteAsync(organization);
await _applicationCacheService.DeleteOrganizationAbilityAsync(organization.Id);
}
private async Task ValidateDeleteOrganizationAsync(Organization organization)
{
var ssoConfig = await _ssoConfigRepository.GetByOrganizationIdAsync(organization.Id);
if (ssoConfig?.GetData()?.MemberDecryptionType == MemberDecryptionType.KeyConnector)
{
throw new BadRequestException("You cannot delete an Organization that is using Key Connector.");
}
}
}
| OrganizationDeleteCommand |
csharp | ServiceStack__ServiceStack | ServiceStack/src/ServiceStack.Interfaces/ValidateAttribute.cs | {
"start": 5326,
"end": 8293
} | public class ____ : AttributeBase, IValidateRule, IReflectAttributeConverter
{
public ValidateAttribute() {}
public ValidateAttribute(string validator) => Validator = validator;
/// <summary>
/// Script Expression to create an IPropertyValidator registered in Validators.Types
/// </summary>
public string Validator { get; set; }
/// <summary>
/// Boolean #Script Code Expression to Test
/// ARGS:
/// - Request: IRequest
/// - dto: Request DTO
/// - field: Property Name
/// - it: Property Value
/// </summary>
public string Condition { get; set; }
[Ignore]
public string[] AllConditions
{
get => throw new NotSupportedException(nameof(AllConditions));
set => Condition = Combine("&&", value);
}
[Ignore]
public string[] AnyConditions
{
get => throw new NotSupportedException(nameof(AnyConditions));
set => Condition = Combine("||", value);
}
/// <summary>
/// Custom ErrorCode to return
/// </summary>
public string ErrorCode { get; set; }
/// <summary>
/// Refer to FluentValidation docs for Variable
/// - {PropertyName}
/// - {PropertyValue}
/// </summary>
public string Message { get; set; }
public static string Combine(string comperand, params string[] conditions)
{
var sb = new StringBuilder();
var joiner = ") " + comperand + " (";
foreach (var condition in conditions)
{
if (string.IsNullOrEmpty(condition))
continue;
if (sb.Length > 0)
sb.Append(joiner);
sb.Append(condition);
}
sb.Insert(0, '(');
sb.Append(')');
return sb.ToString();
}
public ReflectAttribute ToReflectAttribute()
{
var to = new ReflectAttribute {
Name = "Validate",
PropertyArgs = []
};
if (!string.IsNullOrEmpty(Validator))
to.PropertyArgs.Add(new KeyValuePair<PropertyInfo, object>(GetType().GetProperty(nameof(Validator)), Validator));
else if (!string.IsNullOrEmpty(Condition))
to.PropertyArgs.Add(new KeyValuePair<PropertyInfo, object>(GetType().GetProperty(nameof(Condition)), Condition));
if (!string.IsNullOrEmpty(ErrorCode))
to.PropertyArgs.Add(new KeyValuePair<PropertyInfo, object>(GetType().GetProperty(nameof(ErrorCode)), ErrorCode));
if (!string.IsNullOrEmpty(Message))
to.PropertyArgs.Add(new KeyValuePair<PropertyInfo, object>(GetType().GetProperty(nameof(Message)), Message));
return to;
}
}
/// <summary>
/// Override to allow a property to be reset back to their default values using partial updates.
/// By default properties with any validators cannot be reset
/// </summary>
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
| ValidateAttribute |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Adapters/src/Adapters.OpenApi.Core/Diagnostics/OpenApiDiagnosticEventListener.cs | {
"start": 386,
"end": 814
} | public class ____ : IOpenApiDiagnosticEventListener
{
/// <summary>
/// A no-op activity scope that can be returned from
/// event methods that are not interested in when the scope is disposed.
/// </summary>
protected static IDisposable EmptyScope { get; } = new EmptyActivityScope();
public virtual void ValidationErrors(IReadOnlyList<IOpenApiError> errors)
{
}
| OpenApiDiagnosticEventListener |
csharp | dotnet__aspnetcore | src/Mvc/Mvc.ViewFeatures/src/ExpressionHelper.cs | {
"start": 374,
"end": 10224
} | internal static class ____
{
public static string GetUncachedExpressionText(LambdaExpression expression)
=> GetExpressionText(expression, expressionTextCache: null);
public static string GetExpressionText(LambdaExpression expression, ConcurrentDictionary<LambdaExpression, string> expressionTextCache)
{
ArgumentNullException.ThrowIfNull(expression);
if (expressionTextCache != null &&
expressionTextCache.TryGetValue(expression, out var expressionText))
{
return expressionText;
}
// Determine size of string needed (length) and number of segments it contains (segmentCount). Put another
// way, segmentCount tracks the number of times the loop below should iterate. This avoids adding ".model"
// and / or an extra leading "." and then removing them after the loop. Other information collected in this
// first loop helps with length and segmentCount adjustments. doNotCache is somewhat separate: If
// true, expression strings are not cached for the expression.
//
// After the corrections below the first loop, length is usually exactly the size of the returned string.
// However when containsIndexers is true, the calculation is approximate because either evaluating indexer
// expressions multiple times or saving indexer strings can get expensive. Optimizing for the common case
// of a collection (not a dictionary) with less than 100 elements. If that assumption proves to be
// incorrect, the StringBuilder will be enlarged but hopefully just once.
var doNotCache = false;
var lastIsModel = false;
var length = 0;
var segmentCount = 0;
var trailingMemberExpressions = 0;
var part = expression.Body;
while (part != null)
{
switch (part.NodeType)
{
case ExpressionType.Call:
// Will exit loop if at Method().Property or [i,j].Property. In that case (like [i].Property),
// don't cache and don't remove ".Model" (if that's .Property).
doNotCache = true;
lastIsModel = false;
var methodExpression = (MethodCallExpression)part;
if (IsSingleArgumentIndexer(methodExpression))
{
length += "[99]".Length;
part = methodExpression.Object;
segmentCount++;
trailingMemberExpressions = 0;
}
else
{
// Unsupported.
part = null;
}
break;
case ExpressionType.ArrayIndex:
var binaryExpression = (BinaryExpression)part;
doNotCache = true;
lastIsModel = false;
length += "[99]".Length;
part = binaryExpression.Left;
segmentCount++;
trailingMemberExpressions = 0;
break;
case ExpressionType.MemberAccess:
var memberExpressionPart = (MemberExpression)part;
var name = memberExpressionPart.Member.Name;
// If identifier contains "__", it is "reserved for use by the implementation" and likely
// compiler- or Razor-generated e.g. the name of a field in a delegate's generated class.
if (name.Contains("__"))
{
// Exit loop.
part = null;
}
else
{
lastIsModel = string.Equals("model", name, StringComparison.OrdinalIgnoreCase);
length += name.Length + 1;
part = memberExpressionPart.Expression;
segmentCount++;
trailingMemberExpressions++;
}
break;
case ExpressionType.Parameter:
// Unsupported but indicates previous member access was not the view's Model.
lastIsModel = false;
part = null;
break;
default:
// Unsupported.
part = null;
break;
}
}
// If name would start with ".model", then strip that part away.
if (lastIsModel)
{
length -= ".model".Length;
segmentCount--;
trailingMemberExpressions--;
}
// Trim the leading "." if present. The loop below special-cases the last property to avoid this addition.
if (trailingMemberExpressions > 0)
{
length--;
}
Debug.Assert(segmentCount >= 0);
if (segmentCount == 0)
{
Debug.Assert(!doNotCache);
expressionTextCache?.TryAdd(expression, string.Empty);
return string.Empty;
}
var builder = new StringBuilder(length);
part = expression.Body;
while (part != null && segmentCount > 0)
{
segmentCount--;
switch (part.NodeType)
{
case ExpressionType.Call:
Debug.Assert(doNotCache);
var methodExpression = (MethodCallExpression)part;
InsertIndexerInvocationText(builder, methodExpression.Arguments.Single(), expression);
part = methodExpression.Object;
break;
case ExpressionType.ArrayIndex:
Debug.Assert(doNotCache);
var binaryExpression = (BinaryExpression)part;
InsertIndexerInvocationText(builder, binaryExpression.Right, expression);
part = binaryExpression.Left;
break;
case ExpressionType.MemberAccess:
var memberExpression = (MemberExpression)part;
var name = memberExpression.Member.Name;
Debug.Assert(!name.Contains("__"));
builder.Insert(0, name);
if (segmentCount > 0)
{
// One or more parts to the left of this part are coming.
builder.Insert(0, '.');
}
part = memberExpression.Expression;
break;
default:
// Should be unreachable due to handling in above loop.
Debug.Assert(false);
break;
}
}
Debug.Assert(segmentCount == 0);
expressionText = builder.ToString();
if (expressionTextCache != null && !doNotCache)
{
expressionTextCache.TryAdd(expression, expressionText);
}
return expressionText;
}
private static void InsertIndexerInvocationText(
StringBuilder builder,
Expression indexExpression,
LambdaExpression parentExpression)
{
ArgumentNullException.ThrowIfNull(builder);
ArgumentNullException.ThrowIfNull(indexExpression);
ArgumentNullException.ThrowIfNull(parentExpression);
if (parentExpression.Parameters == null)
{
throw new ArgumentException(Resources.FormatPropertyOfTypeCannotBeNull(
nameof(parentExpression.Parameters),
nameof(parentExpression)));
}
var converted = Expression.Convert(indexExpression, typeof(object));
var fakeParameter = Expression.Parameter(typeof(object), null);
var lambda = Expression.Lambda<Func<object, object>>(converted, fakeParameter);
Func<object, object> func;
try
{
func = CachedExpressionCompiler.Process(lambda) ?? lambda.Compile();
}
catch (InvalidOperationException ex)
{
var parameters = parentExpression.Parameters.ToArray();
throw new InvalidOperationException(
Resources.FormatExpressionHelper_InvalidIndexerExpression(indexExpression, parameters[0].Name),
ex);
}
builder.Insert(0, ']');
builder.Insert(0, Convert.ToString(func(null), CultureInfo.InvariantCulture));
builder.Insert(0, '[');
}
public static bool IsSingleArgumentIndexer(Expression expression)
{
if (!(expression is MethodCallExpression methodExpression) || methodExpression.Arguments.Count != 1)
{
return false;
}
// Check whether GetDefaultMembers() (if present in CoreCLR) would return a member of this type. Compiler
// names the indexer property, if any, in a generated [DefaultMember] attribute for the containing type.
var declaringType = methodExpression.Method.DeclaringType;
var defaultMember = declaringType.GetCustomAttribute<DefaultMemberAttribute>(inherit: true);
if (defaultMember == null)
{
return false;
}
// Find default property (the indexer) and confirm its getter is the method in this expression.
var runtimeProperties = declaringType.GetRuntimeProperties();
foreach (var property in runtimeProperties)
{
if ((string.Equals(defaultMember.MemberName, property.Name, StringComparison.Ordinal) &&
property.GetMethod == methodExpression.Method))
{
return true;
}
}
return false;
}
}
| ExpressionHelper |
csharp | Testably__Testably.Abstractions | Source/Testably.Abstractions.Testing/Notification.cs | {
"start": 2087,
"end": 3927
} | private sealed class ____ : IAwaitableCallback<TValue>
{
private readonly Action<TValue>? _callback;
private int _count;
private readonly NotificationFactory<TValue> _factory;
private Func<TValue, bool>? _filter;
private readonly Guid _key;
private readonly Func<TValue, bool> _predicate;
private readonly ManualResetEventSlim _reset;
public CallbackWaiter(NotificationFactory<TValue> factory,
Guid key, Action<TValue>? callback,
Func<TValue, bool>? predicate)
{
_factory = factory;
_key = key;
_callback = callback;
_predicate = predicate ?? (_ => true);
_reset = new ManualResetEventSlim();
}
#region IAwaitableCallback<TValue> Members
/// <inheritdoc cref="IDisposable.Dispose()" />
public void Dispose()
{
_factory.UnRegisterCallback(_key);
_reset.Dispose();
}
/// <inheritdoc cref="IAwaitableCallback{TValue}.Wait(Func{TValue, bool}?, int, int, Action?)" />
public void Wait(Func<TValue, bool>? filter = null,
int timeout = 30000,
int count = 1,
Action? executeWhenWaiting = null)
{
_count = count;
_filter = filter;
_reset.Reset();
Task? task = null;
if (executeWhenWaiting != null)
{
task = Task.Run(executeWhenWaiting.Invoke);
}
if (!_reset.Wait(timeout) ||
task?.Wait(timeout) == false)
{
throw ExceptionFactory.TimeoutExpired(timeout);
}
}
#endregion
/// <summary>
/// Invokes the callback and resets the wait.
/// </summary>
/// <param name="value"></param>
internal void Invoke(TValue value)
{
if (!_predicate.Invoke(value))
{
return;
}
_callback?.Invoke(value);
if (_filter?.Invoke(value) != false &&
Interlocked.Decrement(ref _count) <= 0)
{
_reset.Set();
}
}
}
}
| CallbackWaiter |
csharp | DuendeSoftware__IdentityServer | identity-server/src/Storage/Services/ICorsPolicyService.cs | {
"start": 255,
"end": 507
} | public interface ____
{
/// <summary>
/// Determines whether origin is allowed.
/// </summary>
/// <param name="origin">The origin.</param>
/// <returns></returns>
Task<bool> IsOriginAllowedAsync(string origin);
}
| ICorsPolicyService |
csharp | dotnet__maui | src/Core/src/Handlers/NavigationPage/INavigationViewHandler.cs | {
"start": 439,
"end": 598
} | public partial interface ____ : IViewHandler
{
new IStackNavigationView VirtualView { get; }
new PlatformView PlatformView { get; }
}
} | INavigationViewHandler |
csharp | NSubstitute__NSubstitute | tests/NSubstitute.Acceptance.Specs/FieldReports/Issue291_CannotReconfigureThrowingConfiguration.cs | {
"start": 364,
"end": 429
} | public interface ____ { IResponse Send(IRequest msg); }
| IDeliver |
csharp | microsoft__garnet | test/Garnet.test.cluster/ClusterTestUtils.cs | {
"start": 17266,
"end": 20288
} | public struct ____
{
public string address;
public int port;
public int slot;
public ResponseState state;
public RedisResult result;
public ClusterResponse(string address, int port, int slot, ResponseState state, RedisResult result = null)
{
this.address = address;
this.port = port;
this.slot = slot;
this.state = state;
this.result = result;
}
}
public ClusterResponse ExecuteTxnForShard(int nodeIndex, List<(string, ICollection<object>)> commands, ILogger logger = null)
{
RedisResult result = default;
try
{
var server = GetServer(nodeIndex);
var txnblockResp = (string)server.Execute("MULTI", new List<object>(), CommandFlags.NoRedirect);
ClassicAssert.AreEqual(txnblockResp, "OK");
foreach (var cmd in commands)
{
var respCmd = (string)server.Execute(cmd.Item1, cmd.Item2, CommandFlags.NoRedirect);
ClassicAssert.AreEqual(respCmd, "QUEUED");
}
result = server.Execute("EXEC", new List<object>(), CommandFlags.NoRedirect);
}
catch (Exception ex)
{
var tokens = ex.Message.Split(' ');
if (tokens.Length > 10 && tokens[2].Equals("MOVED"))
{
var address = tokens[5].Split(':')[0];
var port = int.Parse(tokens[5].Split(':')[1]);
var slot = int.Parse(tokens[8]);
var responseState = ResponseState.MOVED;
return new ClusterResponse(address, port, slot, responseState, RedisResult.Create(ex.Message, ResultType.Error));
}
else if (tokens.Length > 10 && tokens[0].Equals("Endpoint"))
{
var address = tokens[1].Split(':')[0];
var port = int.Parse(tokens[1].Split(':')[1]);
var slot = int.Parse(tokens[4]);
var responseState = ResponseState.ASK;
return new ClusterResponse(address, port, slot, responseState, RedisResult.Create(ex.Message, ResultType.Error));
}
else if (ex.Message.StartsWith("CLUSTERDOWN"))
{
var responseState = ResponseState.CLUSTERDOWN;
return new ClusterResponse("", -1, -1, responseState, RedisResult.Create(ex.Message, ResultType.Error));
}
logger?.LogError(ex, "Unexpected exception");
return new ClusterResponse("", -1, -1, ResponseState.NONE, RedisResult.Create(ex.Message, ResultType.Error));
}
return new ClusterResponse("", -1, -1, ResponseState.OK, result);
}
}
public unsafe | ClusterResponse |
csharp | dotnet__orleans | src/Orleans.Core/Runtime/RingRange.cs | {
"start": 8845,
"end": 11353
} | internal sealed class ____ : IRingRangeInternal, ISpanFormattable
{
[Id(0)]
private readonly List<SingleRange> ranges;
[Id(1)]
private readonly long rangeSize;
internal List<SingleRange> Ranges => ranges;
internal GeneralMultiRange(List<SingleRange> ranges)
{
Debug.Assert(ranges.Count != 1);
this.ranges = ranges;
foreach (var r in ranges)
rangeSize += r.RangeSize();
}
internal static IRingRange Create(List<IRingRange> inRanges)
{
var ranges = inRanges.ConvertAll(r => (SingleRange)r);
return HasOverlaps() ? Compact() : new GeneralMultiRange(ranges);
bool HasOverlaps()
{
var last = ranges[0];
for (var i = 1; i < ranges.Count; i++)
{
if (last.Overlaps(last = ranges[i])) return true;
}
return false;
}
IRingRange Compact()
{
var lastIdx = 0;
var last = ranges[0];
for (var i = 1; i < ranges.Count; i++)
{
var r = ranges[i];
if (last.Overlaps(r)) ranges[lastIdx] = last = last.Merge(r);
else ranges[++lastIdx] = last = r;
}
if (lastIdx == 0) return last;
ranges.RemoveRange(++lastIdx, ranges.Count - lastIdx);
return new GeneralMultiRange(ranges);
}
}
public bool InRange(uint n)
{
foreach (var s in ranges)
{
if (s.InRange(n)) return true;
}
return false;
}
public double RangePercentage() => rangeSize * (100.0 / RangeFactory.RING_SIZE);
public override string ToString() => ranges.Count == 0 ? "Empty MultiRange" : $"{this}";
string IFormattable.ToString(string? format, IFormatProvider? formatProvider) => ToString();
bool ISpanFormattable.TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
{
return ranges.Count == 0
? destination.TryWrite($"Empty MultiRange", out charsWritten)
: destination.TryWrite($"<MultiRange: Size=x{rangeSize:X8}, %Ring={RangePercentage():0.000}%>", out charsWritten);
}
}
| GeneralMultiRange |
csharp | unoplatform__uno | src/Uno.UWP/Generated/3.0.0.0/Windows.Devices.Sensors/CompassReadingChangedEventArgs.cs | {
"start": 258,
"end": 464
} | public partial class ____
{
// Skipping already declared property Reading
// Forced skipping of method Windows.Devices.Sensors.CompassReadingChangedEventArgs.Reading.get
}
}
| CompassReadingChangedEventArgs |
csharp | simplcommerce__SimplCommerce | src/Modules/SimplCommerce.Module.Catalog/Areas/Catalog/ViewModels/ProductTranslationForm.cs | {
"start": 71,
"end": 372
} | public class ____
{
public string DefaultCultureName { get; set; }
public string Name { get; set; }
public string ShortDescription { get; set; }
public string Description { get; set; }
public string Specification { get; set; }
}
}
| ProductTranslationForm |
csharp | dotnet__aspnetcore | src/Mvc/Mvc.TagHelpers/src/PersistComponentStateTagHelper.cs | {
"start": 672,
"end": 2386
} | public class ____ : TagHelper
{
private const string TagHelperName = "persist-component-state";
private const string PersistenceModeName = "persist-mode";
private PersistenceMode? _persistenceMode;
/// <summary>
/// Gets or sets the <see cref="Rendering.ViewContext"/> for the current request.
/// </summary>
[HtmlAttributeNotBound]
[ViewContext]
public ViewContext ViewContext { get; set; }
/// <summary>
/// Gets or sets the <see cref="PersistenceMode"/> for the state to persist.
/// </summary>
[HtmlAttributeName(PersistenceModeName)]
public PersistenceMode? PersistenceMode
{
get => _persistenceMode;
set => _persistenceMode = value;
}
/// <inheritdoc />
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
ArgumentNullException.ThrowIfNull(context);
ArgumentNullException.ThrowIfNull(output);
var componentPrerenderer = ViewContext.HttpContext.RequestServices.GetRequiredService<IComponentPrerenderer>();
var serializationMode = PersistenceMode switch
{
null => PersistedStateSerializationMode.Infer,
TagHelpers.PersistenceMode.Server => PersistedStateSerializationMode.Server,
TagHelpers.PersistenceMode.WebAssembly => PersistedStateSerializationMode.WebAssembly,
_ => throw new InvalidOperationException("Invalid persistence mode."),
};
var content = await componentPrerenderer.PrerenderPersistedStateAsync(ViewContext.HttpContext, serializationMode);
output.TagName = null;
output.Content.SetHtmlContent(content);
}
}
| PersistComponentStateTagHelper |
csharp | dotnetcore__FreeSql | Providers/FreeSql.Provider.Xugu/Curd/XuguSelect.cs | {
"start": 19117,
"end": 19679
} | class ____ T9 : class
{
public XuguSelect(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) : base(orm, commonUtils, commonExpression, dywhere) { }
public override string ToSql(string field = null) => XuguSelect<T1>.ToSqlStatic(_commonUtils, _commonExpression, _select, _distinct, field ?? this.GetAllFieldExpressionTreeLevel2().Field, _join, _where, _groupby, _having, _orderby, _skip, _limit, _tables, this.GetTableRuleUnions(), _aliasRule, _tosqlAppendContent, _whereGlobalFilter, _orm);
}
| where |
csharp | dotnet__maui | src/Core/tests/Benchmarks/Stubs/TestServices.cs | {
"start": 181,
"end": 220
} | class ____ : IBarService
{
}
| BarService |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Core/test/Types.Tests/Types/Relay/NodeFieldSupportTests.cs | {
"start": 11382,
"end": 11555
} | public class ____
{
public Bar7 Bar { get; set; } = new() { Id = "123" };
}
[ObjectType("Bar")]
[Node(NodeResolverType = typeof(Bar7Resolver))]
| Foo7 |
csharp | SixLabors__ImageSharp | src/ImageSharp/Formats/Bmp/BmpInfoHeaderType.cs | {
"start": 200,
"end": 282
} | enum ____ is the number of bytes for the specific bitmap header.
/// </summary>
| value |
csharp | ChilliCream__graphql-platform | src/Nitro/CommandLine/src/CommandLine.Cloud/Generated/ApiClient.Client.cs | {
"start": 1078691,
"end": 1078971
} | public partial interface ____ : IListWorkspaceCommand_WorkspaceEdge
{
}
/// <summary>
/// An edge in a connection.
/// </summary>
[global::System.CodeDom.Compiler.GeneratedCode("StrawberryShake", "15.1.8.0")]
| IListWorkspaceCommandQuery_Me_Workspaces_Edges |
csharp | dotnet__BenchmarkDotNet | tests/BenchmarkDotNet.Analyzers.Tests/AnalyzerTests/BenchmarkRunner/RunAnalyzerTests.cs | {
"start": 37488,
"end": 37943
} | class ____<{{typeParameters}}> : BenchmarkClassAncestor2<{{typeParameters}}>
{
}
""";
var benchmarkClassAncestor2Document = /* lang=c#-test */ $$"""
using BenchmarkDotNet.Attributes;
{{genericTypeArgumentsAttributeUsages}}
public {{abstractModifier}} | BenchmarkClassAncestor1 |
csharp | dotnet__aspire | src/Aspire.Hosting/DistributedApplicationBuilder.cs | {
"start": 1790,
"end": 2133
} | interface ____ was created using one of the <see cref="DistributedApplication.CreateBuilder(string[])"/>
/// overloads.
/// </para>
/// <para>
/// For more information on how to configure the <see cref="DistributedApplication" /> using the
/// the builder pattern see <see cref="IDistributedApplicationBuilder" />.
/// </para>
/// </remarks>
| which |
csharp | dotnet__maui | src/Core/src/ImageSources/FontImageSourceService/FontImageSourceService.iOS.cs | {
"start": 252,
"end": 1374
} | public partial class ____
{
public override Task<IImageSourceServiceResult<UIImage>?> GetImageAsync(IImageSource imageSource, float scale = 1, CancellationToken cancellationToken = default) =>
GetImageAsync((IFontImageSource)imageSource, scale, cancellationToken);
public Task<IImageSourceServiceResult<UIImage>?> GetImageAsync(IFontImageSource imageSource, float scale = 1, CancellationToken cancellationToken = default)
{
if (imageSource.IsEmpty)
return FromResult(null);
try
{
// TODO: use a cached way
var image = imageSource.GetPlatformImage(FontManager, scale);
if (image == null)
throw new InvalidOperationException("Unable to generate font image.");
var result = new ImageSourceServiceResult(image, true, () => image.Dispose());
return FromResult(result);
}
catch (Exception ex)
{
Logger?.LogWarning(ex, "Unable to generate font image '{Glyph}'.", imageSource.Glyph);
throw;
}
}
static Task<IImageSourceServiceResult<UIImage>?> FromResult(IImageSourceServiceResult<UIImage>? result) =>
Task.FromResult(result);
}
} | FontImageSourceService |
csharp | microsoft__PowerToys | src/settings-ui/Settings.UI.Library/CmdPalProperties.cs | {
"start": 297,
"end": 1968
} | public class ____
{
// Default shortcut - Win + Alt + Space
public static readonly HotkeySettings DefaultHotkeyValue = new HotkeySettings(true, false, true, false, 32);
#pragma warning disable SA1401 // Fields should be private
#pragma warning disable CA1051 // Do not declare visible instance fields
public HotkeySettings Hotkey;
#pragma warning restore CA1051 // Do not declare visible instance fields
#pragma warning restore SA1401 // Fields should be private
private string _settingsFilePath;
public CmdPalProperties()
{
var localAppDataDir = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
#if DEBUG
_settingsFilePath = Path.Combine(localAppDataDir, "Packages", "Microsoft.CommandPalette.Dev_8wekyb3d8bbwe", "LocalState", "settings.json");
#else
_settingsFilePath = Path.Combine(localAppDataDir, "Packages", "Microsoft.CommandPalette_8wekyb3d8bbwe", "LocalState", "settings.json");
#endif
InitializeHotkey();
}
public void InitializeHotkey()
{
try
{
string json = File.ReadAllText(_settingsFilePath); // Read JSON file
using JsonDocument doc = JsonDocument.Parse(json);
if (doc.RootElement.TryGetProperty(nameof(Hotkey), out JsonElement hotkeyElement))
{
Hotkey = JsonSerializer.Deserialize<HotkeySettings>(hotkeyElement.GetRawText());
}
}
catch (Exception)
{
}
Hotkey ??= DefaultHotkeyValue;
}
}
}
| CmdPalProperties |
csharp | dotnet__aspnetcore | src/Servers/Kestrel/shared/test/Http3/Http3InMemory.cs | {
"start": 18843,
"end": 25643
} | internal class ____
{
internal TaskCompletionSource OnUnidentifiedStreamCreatedTcs { get; } = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
internal TaskCompletionSource OnStreamCreatedTcs { get; } = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
internal TaskCompletionSource OnStreamCompletedTcs { get; } = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
internal TaskCompletionSource OnHeaderReceivedTcs { get; } = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
internal TaskCompletionSource OnDecoderStreamCreatedTcs { get; } = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
internal TaskCompletionSource OnEncoderStreamCreatedTcs { get; } = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
internal TestStreamContext StreamContext { get; }
internal DuplexPipe.DuplexPipePair Pair { get; }
internal Http3InMemory TestBase { get; private protected set; }
internal Http3Connection Connection { get; private protected set; }
public long BytesReceived { get; private set; }
public long Error
{
get => StreamContext.Error;
set => StreamContext.Error = value;
}
public Task OnUnidentifiedStreamCreatedTask => OnUnidentifiedStreamCreatedTcs.Task;
public Task OnStreamCreatedTask => OnStreamCreatedTcs.Task;
public Task OnStreamCompletedTask => OnStreamCompletedTcs.Task;
public Task OnHeaderReceivedTask => OnHeaderReceivedTcs.Task;
public Task OnDecoderStreamCreatedTask => OnDecoderStreamCreatedTcs.Task;
public Task OnEncoderStreamCreatedTask => OnEncoderStreamCreatedTcs.Task;
public ConnectionAbortedException AbortReadException => StreamContext.AbortReadException;
public ConnectionAbortedException AbortWriteException => StreamContext.AbortWriteException;
public Http3StreamBase(TestStreamContext testStreamContext)
{
StreamContext = testStreamContext;
Pair = testStreamContext._pair;
}
protected Task SendAsync(ReadOnlySpan<byte> span)
{
var writableBuffer = Pair.Application.Output;
writableBuffer.Write(span);
return FlushAsync(writableBuffer);
}
protected static Task FlushAsync(PipeWriter writableBuffer)
{
var task = writableBuffer.FlushAsync();
#if IS_TESTS
return task.AsTask().DefaultTimeout();
#else
return task.GetAsTask();
#endif
}
internal async Task ReceiveEndAsync()
{
var result = await ReadApplicationInputAsync();
if (!result.IsCompleted)
{
throw new InvalidOperationException("End not received.");
}
}
#if IS_TESTS
protected Task<ReadResult> ReadApplicationInputAsync()
{
return Pair.Application.Input.ReadAsync().AsTask().DefaultTimeout();
}
#else
protected ValueTask<ReadResult> ReadApplicationInputAsync()
{
return Pair.Application.Input.ReadAsync();
}
#endif
internal async ValueTask<Http3FrameWithPayload> ReceiveFrameAsync(bool expectEnd = false, bool allowEnd = false, Http3FrameWithPayload frame = null)
{
frame ??= new Http3FrameWithPayload();
while (true)
{
var result = await ReadApplicationInputAsync();
var buffer = result.Buffer;
var consumed = buffer.Start;
var examined = buffer.Start;
var copyBuffer = buffer;
try
{
if (buffer.Length == 0)
{
if (result.IsCompleted && allowEnd)
{
return null;
}
throw new InvalidOperationException("No data received.");
}
if (Http3FrameReader.TryReadFrame(ref buffer, frame, isContinuedFrame: false, out var framePayload))
{
consumed = examined = framePayload.End;
frame.Payload = framePayload.ToArray();
if (expectEnd)
{
if (!result.IsCompleted || buffer.Length > 0)
{
throw new Exception("Reader didn't complete with frame");
}
}
return frame;
}
else
{
examined = buffer.End;
}
if (result.IsCompleted)
{
throw new IOException("The reader completed without returning a frame.");
}
}
finally
{
BytesReceived += copyBuffer.Slice(copyBuffer.Start, consumed).Length;
Pair.Application.Input.AdvanceTo(consumed, examined);
}
}
}
internal async Task SendFrameAsync(Http3FrameType frameType, Memory<byte> data, bool endStream = false)
{
var outputWriter = Pair.Application.Output;
Http3FrameWriter.WriteHeader(frameType, data.Length, outputWriter);
if (!endStream)
{
await SendAsync(data.Span);
}
else
{
// Write and end stream at the same time.
// Avoid race condition of frame read separately from end of stream.
await EndStreamAsync(data.Span);
}
}
internal Task EndStreamAsync(ReadOnlySpan<byte> span = default)
{
var writableBuffer = Pair.Application.Output;
if (span.Length > 0)
{
writableBuffer.Write(span);
}
return writableBuffer.CompleteAsync().AsTask();
}
internal async Task WaitForStreamErrorAsync(Http3ErrorCode protocolError, Action<string> matchExpectedErrorMessage = null, string expectedErrorMessage = null)
{
try
{
var result = await ReadApplicationInputAsync();
if (!result.IsCompleted)
{
throw new InvalidOperationException("Stream not ended.");
}
}
catch (ConnectionAbortedException)
{
// no-op, this just means that the stream was aborted prior to the read ending. This is probably
// intentional, so go onto invoking the comparisons
}
finally
{
if (protocolError != Http3ErrorCode.NoError && (Http3ErrorCode)Error != protocolError)
{
throw new InvalidOperationException($"Expected error code {protocolError}, got {(Http3ErrorCode)Error}.");
}
matchExpectedErrorMessage?.Invoke(expectedErrorMessage);
}
}
}
| Http3StreamBase |
csharp | dotnet__efcore | test/EFCore.Specification.Tests/GraphUpdates/ProxyGraphUpdatesFixtureBase.cs | {
"start": 60643,
"end": 61178
} | public class ____
{
protected OptionalSingleAk2()
{
}
public virtual int Id { get; set; }
public virtual Guid AlternateId { get; set; }
public virtual Guid? BackId { get; set; }
public virtual OptionalSingleAk1 Back { get; set; }
public override bool Equals(object obj)
{
var other = obj as OptionalSingleAk2;
return Id == other?.Id;
}
public override int GetHashCode()
=> Id;
}
| OptionalSingleAk2 |
csharp | abpframework__abp | framework/test/Volo.Abp.BlobStoring.Minio.Tests/Volo/Abp/BlobStoring/Minio/MinioBlobContainer_Tests.cs | {
"start": 125,
"end": 271
} | public class ____ : BlobContainer_Tests<AbpBlobStoringMinioTestModule>
{
public MinioBlobContainer_Tests()
{
}
}
*/ | MinioBlobContainer_Tests |
csharp | DuendeSoftware__IdentityServer | identity-server/src/Configuration/Extensions/ConfigurationServiceCollectionExtensions.cs | {
"start": 636,
"end": 717
} | class ____ setting up services for IdentityServer.Configuration.
/// </summary>
| for |
csharp | AutoFixture__AutoFixture | Src/AutoFixtureUnitTest/RecursionGuardTest.cs | {
"start": 6110,
"end": 24174
} | private class ____ : Exception
{
public PrivateUnexpectedException(string message)
: base(message)
{
}
}
[Fact]
public void CreateWillTriggerHandlingOnSecondLevelRecursiveRequest()
{
// Arrange
object subRequest1 = Guid.NewGuid();
object subRequest2 = Guid.NewGuid();
var requestScenario = new Stack<object>(new[] { subRequest1, subRequest2, subRequest1 });
var builder = new DelegatingSpecimenBuilder();
builder.OnCreate = (r, c) => c.Resolve(requestScenario.Pop());
var sut = new DelegatingRecursionGuard(builder);
object recursiveRequest = null;
sut.OnHandleRecursiveRequest = obj => recursiveRequest = obj;
var container = new DelegatingSpecimenContext();
container.OnResolve = (r) => sut.Create(r, container);
// Act
sut.Create(Guid.NewGuid(), container);
// Assert
Assert.Same(subRequest1, recursiveRequest);
}
[Fact]
public void CreateWillNotTriggerHandlingUntilDeeperThanRecursionDepth()
{
// Arrange
var requestScenario = new Queue<int>(new[] { 1, 2, 1, 3, 1, 4 });
var builder = new DelegatingSpecimenBuilder();
builder.OnCreate = (r, c) => c.Resolve(requestScenario.Dequeue());
// By setting the depth to two we expect the handle to be triggered at the third "1" occurrence.
var sut = new DelegatingRecursionGuard(builder, 2);
object recursiveRequest = null;
sut.OnHandleRecursiveRequest = obj => recursiveRequest = obj;
var container = new DelegatingSpecimenContext();
container.OnResolve = r => sut.Create(r, container);
// Act
sut.Create(5, container);
// Assert
// Check that recursion was actually detected as expected
Assert.Equal(1, recursiveRequest);
// Check that we passed the first recursion, but didn't go any further
Assert.Equal(4, requestScenario.Dequeue());
}
[Fact]
public void ConstructWithBuilderAndRecursionHandlerHasCorrectHandler()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var expected = new DelegatingRecursionHandler();
var sut = new RecursionGuard(dummyBuilder, expected);
// Act
IRecursionHandler actual = sut.RecursionHandler;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithBuilderAndRecursionHandlerHasCorrectBuilder()
{
// Arrange
var expected = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var sut = new RecursionGuard(expected, dummyHandler);
// Act
var actual = sut.Builder;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithBuilderAndRecursionHandlerHasCorrectComparer()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var sut = new RecursionGuard(dummyBuilder, dummyHandler);
// Act
var actual = sut.Comparer;
// Assert
Assert.Equal(EqualityComparer<object>.Default, actual);
}
[Fact]
public void ConstructWithNullBuilderAndRecursionHandlerThrows()
{
// Arrange
var dummyHandler = new DelegatingRecursionHandler();
// Act & assert
Assert.Throws<ArgumentNullException>(
() => new RecursionGuard(null, dummyHandler));
}
[Fact]
public void ConstructWithBuilderAndNullRecursionHandlerThrows()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
// Act & assert
Assert.Throws<ArgumentNullException>(
() => new RecursionGuard(dummyBuilder, (IRecursionHandler)null));
}
[Fact]
public void ConstructWithBuilderAndHandlerAndComparerAndRecursionDepthHasCorrectBuilder()
{
// Arrange
var expected = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
var dummyRecursionDepth = 2;
var sut = new RecursionGuard(expected, dummyHandler, dummyComparer, dummyRecursionDepth);
// Act
var actual = sut.Builder;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithBuilderAndHandlerAndComparerAndRecursionDepthHasCorrectHandler()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var expected = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
var dummyRecursionDepth = 2;
var sut = new RecursionGuard(dummyBuilder, expected, dummyComparer, dummyRecursionDepth);
// Act
var actual = sut.RecursionHandler;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithBuilderAndHandlerAndComparerAndRecursionDepthHasCorrectComparer()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var expected = new DelegatingEqualityComparer();
var dummyRecursionDepth = 2;
var sut = new RecursionGuard(dummyBuilder, dummyHandler, expected, dummyRecursionDepth);
// Act
var actual = sut.Comparer;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithBuilderAndHandlerAndComparerAndRecursionDepthHasCorrectRecursionDepth()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
var expected = 2;
var sut = new RecursionGuard(dummyBuilder, dummyHandler, dummyComparer, expected);
// Act
var actual = sut.RecursionDepth;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithNullBuilderAndHandlerAndComparerAndRecursionDepthThrows()
{
// Arrange
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
var dummyRecursionDepth = 2;
// Act & assert
Assert.Throws<ArgumentNullException>(
() => new RecursionGuard(null, dummyHandler, dummyComparer, dummyRecursionDepth));
}
[Fact]
public void ConstructWithBuilderAndNullHandlerAndComparerAndRecursionDepthThrows()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyComparer = new DelegatingEqualityComparer();
var dummyRecursionDepth = 2;
// Act & assert
Assert.Throws<ArgumentNullException>(
() => new RecursionGuard(dummyBuilder, null, dummyComparer, dummyRecursionDepth));
}
[Fact]
public void ConstructWithBuilderAndHandlerAndNullComparerAndRecursionDepthThrows()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyRecursionDepth = 2;
// Act & assert
Assert.Throws<ArgumentNullException>(
() => new RecursionGuard(dummyBuilder, dummyHandler, null, dummyRecursionDepth));
}
[Fact]
[Obsolete]
public void ConstructWithBuilderSetsRecursionDepthCorrectly()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
// Act
#pragma warning disable 618
var sut = new RecursionGuard(dummyBuilder);
#pragma warning restore 618
// Assert
Assert.Equal(1, sut.RecursionDepth);
}
[Fact]
public void ConstructWithBuilderAndHandlerSetsRecursionDepthCorrectly()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
// Act
var sut = new RecursionGuard(dummyBuilder, dummyHandler);
// Assert
Assert.Equal(1, sut.RecursionDepth);
}
[Fact]
[Obsolete]
public void ConstructWithBuilderAndHandlerAndComparerHasCorrectBuilder()
{
// Arrange
var expected = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
#pragma warning disable 618
var sut = new RecursionGuard(expected, dummyHandler, dummyComparer);
#pragma warning restore 618
// Act
var actual = sut.Builder;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
[Obsolete]
public void ConstructWithBuilderAndHandlerAndComparerHasCorrectHandler()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var expected = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
#pragma warning disable 618
var sut = new RecursionGuard(dummyBuilder, expected, dummyComparer);
#pragma warning restore 618
// Act
var actual = sut.RecursionHandler;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
[Obsolete]
public void ConstructWithBuilderAndHandlerAndComparerHasCorrectComparer()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var expected = new DelegatingEqualityComparer();
#pragma warning disable 618
var sut = new RecursionGuard(dummyBuilder, dummyHandler, expected);
#pragma warning restore 618
// Act
var actual = sut.Comparer;
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ConstructWithBuilderAndHandlerAndRecursionDepthSetsRecursionDepthCorrectly()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
const int explicitRecursionDepth = 2;
// Act
var sut = new RecursionGuard(dummyBuilder, dummyHandler, explicitRecursionDepth);
// Assert
Assert.Equal(explicitRecursionDepth, sut.RecursionDepth);
}
[Fact]
public void CreateReturnsResultFromInjectedHandlerWhenRequestIsMatched()
{
// Arrange
var builder = new DelegatingSpecimenBuilder()
{
OnCreate = (r, ctx) => ctx.Resolve(r)
};
var request = new object();
var expected = new object();
var handlerStub = new DelegatingRecursionHandler
{
OnHandleRecursiveRequest = (r, rs) =>
{
Assert.Equal(request, r);
Assert.NotNull(rs);
return expected;
}
};
var comparer = new DelegatingEqualityComparer
{
OnEquals = (x, y) => true
};
var sut = new RecursionGuard(builder, handlerStub, comparer, 1);
var context = new DelegatingSpecimenContext();
context.OnResolve = r => sut.Create(r, context);
// Act
var actual = sut.Create(request, context);
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void ComposeReturnsCorrectResult()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
const int dummyRecursionDepth = 2;
var sut = new RecursionGuard(dummyBuilder, dummyHandler, dummyComparer, dummyRecursionDepth);
// Act
var expectedBuilders = new[]
{
new DelegatingSpecimenBuilder(),
new DelegatingSpecimenBuilder(),
new DelegatingSpecimenBuilder()
};
var actual = sut.Compose(expectedBuilders);
// Assert
var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
var composite = Assert.IsAssignableFrom<CompositeSpecimenBuilder>(rg.Builder);
Assert.True(expectedBuilders.SequenceEqual(composite));
}
[Fact]
public void ComposeSingleItemReturnsCorrectResult()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
int dummyRecursionDepth = 2;
var sut = new RecursionGuard(dummyBuilder, dummyHandler, dummyComparer, dummyRecursionDepth);
// Act
var expected = new DelegatingSpecimenBuilder();
var actual = sut.Compose(new[] { expected });
// Assert
var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
Assert.Equal(expected, rg.Builder);
}
[Fact]
public void ComposeRetainsHandler()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var expected = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
int dummyRecursionDepth = 2;
var sut = new RecursionGuard(dummyBuilder, expected, dummyComparer, dummyRecursionDepth);
// Act
var actual = sut.Compose(new ISpecimenBuilder[0]);
// Assert
var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
Assert.Equal(expected, rg.RecursionHandler);
}
[Fact]
public void ComposeRetainsComparer()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var expected = new DelegatingEqualityComparer();
int dummyRecursionDepth = 2;
var sut = new RecursionGuard(dummyBuilder, dummyHandler, expected, dummyRecursionDepth);
// Act
var actual = sut.Compose(new ISpecimenBuilder[0]);
// Assert
var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
Assert.Equal(expected, rg.Comparer);
}
[Fact]
public void ComposeRetainsRecursionDepth()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
int expected = 2;
var sut = new RecursionGuard(dummyBuilder, dummyHandler, dummyComparer, expected);
// Act
var actual = sut.Compose(new ISpecimenBuilder[0]);
// Assert
var rg = Assert.IsAssignableFrom<RecursionGuard>(actual);
Assert.Equal(expected, rg.RecursionDepth);
}
[Fact]
public void CreateOnMultipleThreadsConcurrentlyWorks()
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder
{
OnCreate = (r, ctx) => ctx.Resolve(r)
};
var dummyHandler = new DelegatingRecursionHandler();
var sut = new RecursionGuard(dummyBuilder, dummyHandler);
var dummyContext = new DelegatingSpecimenContext()
{
OnResolve = (r) => 99
};
// Act
int[] specimens = Enumerable.Range(0, 1000)
.AsParallel()
.WithDegreeOfParallelism(8)
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.Select(x => (int)sut.Create(typeof(int), dummyContext))
.ToArray();
// Assert
Assert.Equal(1000, specimens.Length);
Assert.True(specimens.All(s => s == 99));
}
[Theory]
[InlineData(0)]
[InlineData(-7)]
[InlineData(-42)]
public void ConstructorWithRecursionDepthLowerThanOneThrows(int recursionDepth)
{
// Arrange
var dummyBuilder = new DelegatingSpecimenBuilder();
var dummyHandler = new DelegatingRecursionHandler();
var dummyComparer = new DelegatingEqualityComparer();
// Act & assert
Assert.Throws<ArgumentOutOfRangeException>(() =>
new RecursionGuard(dummyBuilder, dummyHandler, dummyComparer, recursionDepth));
}
}
} | PrivateUnexpectedException |
csharp | MaterialDesignInXAML__MaterialDesignInXamlToolkit | src/MaterialDesignThemes.Wpf/ClockChoiceMadeEventArgs.cs | {
"start": 131,
"end": 784
} | public class ____ : RoutedEventArgs
{
private readonly ClockDisplayMode _displayMode;
public ClockChoiceMadeEventArgs(ClockDisplayMode displayMode)
{
_displayMode = displayMode;
}
public ClockChoiceMadeEventArgs(ClockDisplayMode displayMode, RoutedEvent routedEvent) : base(routedEvent)
{
_displayMode = displayMode;
}
public ClockChoiceMadeEventArgs(ClockDisplayMode displayMode, RoutedEvent routedEvent, object source) : base(routedEvent, source)
{
_displayMode = displayMode;
}
public ClockDisplayMode Mode
{
get { return _displayMode; }
}
}
| ClockChoiceMadeEventArgs |
csharp | dotnet__orleans | src/api/Orleans.Serialization/Orleans.Serialization.cs | {
"start": 81370,
"end": 82527
} | partial class ____<T> : IFieldCodec<System.Collections.Generic.HashSet<T>>, IFieldCodec, Serializers.IBaseCodec<System.Collections.Generic.HashSet<T>>, Serializers.IBaseCodec
{
public HashSetCodec(IFieldCodec<T> fieldCodec, IFieldCodec<System.Collections.Generic.IEqualityComparer<T>> comparerCodec) { }
void Serializers.IBaseCodec<System.Collections.Generic.HashSet<T>>.Deserialize<TInput>(ref Buffers.Reader<TInput> reader, System.Collections.Generic.HashSet<T> value) { }
public System.Collections.Generic.HashSet<T> ReadValue<TInput>(ref Buffers.Reader<TInput> reader, WireProtocol.Field field) { throw null; }
public void Serialize<TBufferWriter>(ref Buffers.Writer<TBufferWriter> writer, System.Collections.Generic.HashSet<T> value)
where TBufferWriter : System.Buffers.IBufferWriter<byte> { }
public void WriteField<TBufferWriter>(ref Buffers.Writer<TBufferWriter> writer, uint fieldIdDelta, System.Type expectedType, System.Collections.Generic.HashSet<T> value)
where TBufferWriter : System.Buffers.IBufferWriter<byte> { }
}
[RegisterCopier]
public sealed | HashSetCodec |
csharp | DuendeSoftware__IdentityServer | identity-server/src/IdentityServer/Licensing/V2/Diagnostics/ClientLoadedTracker.cs | {
"start": 358,
"end": 4238
} | internal class ____ : IDisposable
{
private const int MaxClientsTrackedCount = 100;
private const int ArrayMaxSize = 10;
private int _clientCount;
private readonly ConcurrentDictionary<string, JsonObject> _clients = new();
private readonly List<string> _propertiesToExclude = [nameof(Client.Properties), nameof(Client.LogoUri), nameof(Client.Claims)];
private readonly JsonDocument _defaultClient;
private readonly JsonSerializerOptions _serializerOptions = new()
{
Converters = { new JsonStringEnumConverter() },
WriteIndented = false
};
public ClientLoadedTracker() => _defaultClient = JsonSerializer.SerializeToDocument(new Client { ClientId = "" }, _serializerOptions);
public void TrackClientLoaded(Client client)
{
if (_clientCount >= MaxClientsTrackedCount)
{
return;
}
using var clientJson = JsonSerializer.SerializeToDocument(client, _serializerOptions);
var clientDiagnosticData = new JsonObject();
foreach (var property in _defaultClient.RootElement.EnumerateObject())
{
if (_propertiesToExclude.Contains(property.Name))
{
continue;
}
if (!_defaultClient.RootElement.TryGetProperty(property.Name, out var defaultValue) ||
!clientJson.RootElement.TryGetProperty(property.Name, out var clientValue))
{
continue;
}
if (property.NameEquals(nameof(Client.ClientSecrets)))
{
var secrets = clientValue.EnumerateArray()
.Select(secret => secret.GetProperty(nameof(Secret.Type)).GetString())
.Distinct()
.Select(secret => JsonValue.Create(secret))
.Cast<JsonNode>();
clientDiagnosticData["SecretTypes"] = new JsonArray(secrets.ToArray());
}
else if (defaultValue.ValueKind == JsonValueKind.Array && clientValue.ValueKind == JsonValueKind.Array && clientValue.GetArrayLength() > 0)
{
var arrayEntries = clientValue.EnumerateArray().Take(ArrayMaxSize).Select(CreateJsonValue).Cast<JsonNode>();
clientDiagnosticData[property.Name] = new JsonArray(arrayEntries.ToArray());
}
else
{
if (!JsonElementEquals(defaultValue, clientValue))
{
clientDiagnosticData[property.Name] = CreateJsonValue(clientValue);
}
}
}
if (_clients.ContainsKey(client.ClientId))
{
return;
}
if (_clients.TryAdd(client.ClientId, clientDiagnosticData))
{
Interlocked.Increment(ref _clientCount);
}
}
private static bool JsonElementEquals(JsonElement a, JsonElement b)
{
if (a.ValueKind != b.ValueKind)
{
return false;
}
return a.ValueKind switch
{
JsonValueKind.String => a.GetString() == b.GetString(),
JsonValueKind.Number => a.GetDouble().CompareTo(b.GetDouble()) == 0,
JsonValueKind.True or JsonValueKind.False => a.GetBoolean() == b.GetBoolean(),
_ => a.ToString() == b.ToString()
};
}
private JsonValue? CreateJsonValue(JsonElement element) => element.ValueKind switch
{
JsonValueKind.String => JsonValue.Create(element.GetString()),
JsonValueKind.Number => JsonValue.Create(element.GetDouble()),
JsonValueKind.True or JsonValueKind.False => JsonValue.Create(element.GetBoolean()),
_ => JsonValue.Create(element.ToString())
};
public IReadOnlyDictionary<string, JsonObject> Clients => _clients;
public void Dispose() => _defaultClient.Dispose();
}
| ClientLoadedTracker |
csharp | mongodb__mongo-csharp-driver | tests/MongoDB.Bson.Tests/Serialization/Serializers/StackSerializerTests.cs | {
"start": 679,
"end": 2323
} | public class ____
{
[Fact]
public void Equals_null_should_return_false()
{
var x = new StackSerializer();
var result = x.Equals(null);
result.Should().Be(false);
}
[Fact]
public void Equals_object_should_return_false()
{
var x = new StackSerializer();
var y = new object();
var result = x.Equals(y);
result.Should().Be(false);
}
[Fact]
public void Equals_self_should_return_true()
{
var x = new StackSerializer();
var result = x.Equals(x);
result.Should().Be(true);
}
[Fact]
public void Equals_with_equal_fields_should_return_true()
{
var x = new StackSerializer();
var y = new StackSerializer();
var result = x.Equals(y);
result.Should().Be(true);
}
[Fact]
public void Equals_with_not_equal_field_should_return_false()
{
var itemSerializer1 = new Int32Serializer(BsonType.Int32);
var itemSerializer2 = new Int32Serializer(BsonType.String);
var x = new StackSerializer(itemSerializer1);
var y = new StackSerializer(itemSerializer2);
var result = x.Equals(y);
result.Should().Be(false);
}
[Fact]
public void GetHashCode_should_return_zero()
{
var x = new StackSerializer();
var result = x.GetHashCode();
result.Should().Be(0);
}
}
| StackSerializerTests |
csharp | SixLabors__Fonts | src/SixLabors.Fonts/GlyphColor.cs | {
"start": 293,
"end": 7284
} | partial struct ____ : IEquatable<GlyphColor>
{
internal GlyphColor(byte red, byte green, byte blue, byte alpha)
{
this.R = red;
this.G = green;
this.B = blue;
this.A = alpha;
}
/// <summary>
/// Gets the red component
/// </summary>
public readonly byte R { get; }
/// <summary>
/// Gets the green component
/// </summary>
public readonly byte G { get; }
/// <summary>
/// Gets the blue component
/// </summary>
public readonly byte B { get; }
/// <summary>
/// Gets the alpha component
/// </summary>
public readonly byte A { get; }
/// <summary>
/// Compares two <see cref="GlyphColor"/> objects for equality.
/// </summary>
/// <param name="left">
/// The <see cref="GlyphColor"/> on the left side of the operand.
/// </param>
/// <param name="right">
/// The <see cref="GlyphColor"/> on the right side of the operand.
/// </param>
/// <returns>
/// True if the current left is equal to the <paramref name="right"/> parameter; otherwise, false.
/// </returns>
public static bool operator ==(GlyphColor left, GlyphColor right)
=> left.Equals(right);
/// <summary>
/// Compares two <see cref="GlyphColor"/> objects for inequality.
/// </summary>
/// <param name="left">
/// The <see cref="GlyphColor"/> on the left side of the operand.
/// </param>
/// <param name="right">
/// The <see cref="GlyphColor"/> on the right side of the operand.
/// </param>
/// <returns>
/// True if the current left is unequal to the <paramref name="right"/> parameter; otherwise, false.
/// </returns>
public static bool operator !=(GlyphColor left, GlyphColor right)
=> !left.Equals(right);
/// <inheritdoc/>
public override bool Equals(object? obj)
=> obj is GlyphColor p && this.Equals(p);
/// <summary>
/// Compares the <see cref="GlyphColor"/> for equality to this color.
/// </summary>
/// <param name="other">
/// The other <see cref="GlyphColor"/> to compare to.
/// </param>
/// <returns>
/// True if the current color is equal to the <paramref name="other"/> parameter; otherwise, false.
/// </returns>
public bool Equals(GlyphColor other)
=> other.R == this.R
&& other.G == this.G
&& other.B == this.B
&& other.A == this.A;
/// <inheritdoc/>
public override int GetHashCode()
=> HashCode.Combine(
this.R,
this.G,
this.B,
this.A);
/// <summary>
/// Gets the hexadecimal string representation of the color instance in the format RRGGBBAA.
/// </summary>
/// <param name="value">
/// The hexadecimal representation of the combined color components.
/// </param>
/// <param name="result">
/// When this method returns, contains the <see cref="GlyphColor"/> equivalent of the hexadecimal input.
/// </param>
/// <returns>
/// <see langword="true"/> if the parsing was successful; otherwise, <see langword="false"/>.
/// </returns>
public static bool TryParseHex(string? value, [NotNullWhen(true)] out GlyphColor result)
{
result = default;
if (string.IsNullOrWhiteSpace(value))
{
return false;
}
ReadOnlySpan<char> hex = value.AsSpan();
if (hex[0] != '#')
{
return false;
}
hex = hex[1..];
byte a = 255, r, g, b;
switch (hex.Length)
{
case 8:
if (!TryParseByte(hex[0], hex[1], out r) ||
!TryParseByte(hex[2], hex[3], out g) ||
!TryParseByte(hex[4], hex[5], out b) ||
!TryParseByte(hex[6], hex[7], out a))
{
return false;
}
break;
case 6:
if (!TryParseByte(hex[0], hex[1], out r) ||
!TryParseByte(hex[2], hex[3], out g) ||
!TryParseByte(hex[4], hex[5], out b))
{
return false;
}
break;
case 4:
if (!TryExpand(hex[0], out r) ||
!TryExpand(hex[1], out g) ||
!TryExpand(hex[2], out b) ||
!TryExpand(hex[3], out a))
{
return false;
}
break;
case 3:
if (!TryExpand(hex[0], out r) ||
!TryExpand(hex[1], out g) ||
!TryExpand(hex[2], out b))
{
return false;
}
break;
default:
return false;
}
result = new GlyphColor(r, g, b, a);
return true;
}
/// <summary>
/// Attempts to parse the specified name into a corresponding named glyph color.
/// </summary>
/// <param name="name">The name of the glyph color to parse.</param>
/// <param name="result">
/// When this method returns, contains the parsed <see cref="GlyphColor"/> value if the parse operation succeeded;
/// otherwise, contains the default value.
/// </param>
/// <returns>
/// <see langword="true"/> if the parsing was successful; otherwise, <see langword="false"/>.
/// </returns>
public static bool TryParseNamed(string? name, [NotNullWhen(true)] out GlyphColor result)
{
result = default;
if (string.IsNullOrWhiteSpace(name))
{
return false;
}
return NamedGlyphColorsLookupLazy.Value.TryGetValue(name, out result);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool TryParseByte(char hi, char lo, out byte value)
{
if (TryConvertHexCharToByte(hi, out byte high) && TryConvertHexCharToByte(lo, out byte low))
{
value = (byte)((high << 4) | low);
return true;
}
value = 0;
return false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool TryExpand(char c, out byte value)
{
if (TryConvertHexCharToByte(c, out byte nibble))
{
value = (byte)((nibble << 4) | nibble);
return true;
}
value = 0;
return false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static bool TryConvertHexCharToByte(char c, out byte value)
{
if ((uint)(c - '0') <= 9)
{
value = (byte)(c - '0');
return true;
}
char lower = (char)(c | 0x20); // Normalize to lowercase
if ((uint)(lower - 'a') <= 5)
{
value = (byte)(lower - 'a' + 10);
return true;
}
value = 0;
return false;
}
}
| GlyphColor |
csharp | dotnet__maui | src/Controls/src/Xaml/MarkupExtensions/OnPlatformExtension.cs | {
"start": 514,
"end": 5516
} | public class ____ : IMarkupExtension
{
static object s_notset = new object();
public object Default { get; set; } = s_notset;
public object Android { get; set; } = s_notset;
internal object GTK { get; set; } = s_notset;
public object iOS { get; set; } = s_notset;
internal object macOS { get; set; } = s_notset;
public object MacCatalyst { get; set; } = s_notset;
public object Tizen { get; set; } = s_notset;
[Obsolete("Use WinUI instead.")]
public object UWP { get; set; } = s_notset;
internal object WPF { get; set; } = s_notset;
public object WinUI { get; set; } = s_notset;
public IValueConverter Converter { get; set; }
public object ConverterParameter { get; set; }
public object ProvideValue(IServiceProvider serviceProvider)
{
if (Android == s_notset
&& GTK == s_notset
&& iOS == s_notset
&& macOS == s_notset
&& MacCatalyst == s_notset
&& Tizen == s_notset
#pragma warning disable CS0618 // Type or member is obsolete
&& UWP == s_notset
#pragma warning restore CS0618 // Type or member is obsolete
&& WPF == s_notset
&& WinUI == s_notset
&& Default == s_notset)
{
throw new XamlParseException("OnPlatformExtension requires a value to be specified for at least one platform or Default.", serviceProvider);
}
var valueProvider = serviceProvider?.GetService<IProvideValueTarget>() ?? throw new ArgumentException();
BindableProperty bp;
PropertyInfo pi = null;
Type propertyType = null;
if (valueProvider.TargetObject is Setter setter)
bp = setter.Property;
else
{
bp = valueProvider.TargetProperty as BindableProperty;
pi = valueProvider.TargetProperty as PropertyInfo;
}
propertyType = bp?.ReturnType
?? pi?.PropertyType
?? throw new InvalidOperationException("Cannot determine property to provide the value for.");
if (!TryGetValueForPlatform(out var value))
{
if (bp != null)
{
object targetObject = valueProvider.TargetObject;
if (targetObject is Setter)
return null;
else
return bp.GetDefaultValue(targetObject as BindableObject);
}
if (propertyType.IsValueType)
return Activator.CreateInstance(propertyType);
return null;
}
if (Converter != null)
return Converter.Convert(value, propertyType, ConverterParameter, CultureInfo.CurrentUICulture);
var converterProvider = serviceProvider?.GetService<IValueConverterProvider>();
if (converterProvider != null)
{
MemberInfo minforetriever()
{
if (pi != null)
return pi;
MemberInfo minfo = null;
try
{
minfo = bp.DeclaringType.GetRuntimeProperty(bp.PropertyName);
}
catch (AmbiguousMatchException e)
{
throw new XamlParseException($"Multiple properties with name '{bp.DeclaringType}.{bp.PropertyName}' found.", serviceProvider, innerException: e);
}
if (minfo != null)
return minfo;
try
{
return bp.DeclaringType.GetRuntimeMethod("Get" + bp.PropertyName, new[] { typeof(BindableObject) });
}
catch (AmbiguousMatchException e)
{
throw new XamlParseException($"Multiple methods with name '{bp.DeclaringType}.Get{bp.PropertyName}' found.", serviceProvider, innerException: e);
}
}
return converterProvider.Convert(value, propertyType, minforetriever, serviceProvider);
}
var ret = value.ConvertTo(propertyType, () => pi, serviceProvider, out Exception exception);
if (exception != null)
throw exception;
return ret;
}
bool TryGetValueForPlatform(out object value)
{
if (DeviceInfo.Platform == DevicePlatform.Android && Android != s_notset)
{
value = Android;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.Create("GTK") && GTK != s_notset)
{
value = GTK;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.iOS && iOS != s_notset)
{
value = iOS;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.macOS && macOS != s_notset)
{
value = macOS;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.MacCatalyst && MacCatalyst != s_notset)
{
value = MacCatalyst;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.Tizen && Tizen != s_notset)
{
value = Tizen;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.WinUI && WinUI != s_notset)
{
value = WinUI;
return true;
}
#pragma warning disable CS0618 // Type or member is obsolete
if (DeviceInfo.Platform == DevicePlatform.WinUI && UWP != s_notset)
{
value = UWP;
return true;
}
if (DeviceInfo.Platform == DevicePlatform.Create("UWP") && UWP != s_notset)
{
value = UWP;
return true;
}
#pragma warning restore CS0618 // Type or member is obsolete
if (DeviceInfo.Platform == DevicePlatform.Create("WPF") && WPF != s_notset)
{
value = WPF;
return true;
}
value = Default;
return value != s_notset;
}
}
} | OnPlatformExtension |
csharp | microsoft__semantic-kernel | dotnet/src/Functions/Functions.Markdown/MarkdownKernelExtensions.cs | {
"start": 200,
"end": 1507
} | public static class ____
{
/// <summary>
/// Creates a <see cref="KernelFunction"/> instance for a prompt function using the specified markdown text.
/// </summary>
/// <param name="kernel">The <see cref="Kernel"/> containing services, plugins, and other state for use throughout the operation.</param>
/// <param name="text">YAML representation of the <see cref="PromptTemplateConfig"/> to use to create the prompt function</param>
/// <param name="functionName">The name of the function.</param>
/// <param name="promptTemplateFactory">
/// The <see cref="IPromptTemplateFactory"/> to use when interpreting the prompt template configuration into a <see cref="IPromptTemplate"/>.
/// If null, a default factory will be used.
/// </param>
/// <returns>The created <see cref="KernelFunction"/>.</returns>
public static KernelFunction CreateFunctionFromMarkdown(
this Kernel kernel,
string text,
string functionName,
IPromptTemplateFactory? promptTemplateFactory = null)
{
Verify.NotNull(kernel);
Verify.NotNull(text);
Verify.NotNull(functionName);
return KernelFunctionMarkdown.FromPromptMarkdown(text, functionName, promptTemplateFactory, kernel.LoggerFactory);
}
}
| MarkdownKernelExtensions |
csharp | unoplatform__uno | src/Uno.UI.Runtime.Skia.Linux.FrameBuffer/Native/fb_bitfield.cs | {
"start": 442,
"end": 665
} | struct ____
{
public __u32 offset; /* beginning of bitfield */
public __u32 length; /* length of bitfield */
public __u32 msb_right; /* != 0 : Most significant bit is */
/* right */
}
}
| fb_bitfield |
csharp | microsoft__semantic-kernel | dotnet/src/VectorData/InMemory/InMemoryVectorStoreExtensions.cs | {
"start": 2651,
"end": 3807
} | record ____.</typeparam>
/// <typeparam name="TRecord">Type of the record.</typeparam>
/// <param name="vectorStore">Instance of <see cref="InMemoryVectorStore"/> used to retrieve the collection.</param>
/// <param name="stream">The stream to read the serialized JSON from.</param>
[RequiresDynamicCode("This method is incompatible with NativeAOT.")]
[RequiresUnreferencedCode("This method is incompatible with trimming.")]
public static async Task<VectorStoreCollection<TKey, TRecord>?> DeserializeCollectionFromJsonAsync<TKey, TRecord>(
this InMemoryVectorStore vectorStore,
Stream stream)
where TKey : notnull
where TRecord : class
{
VectorStoreCollection<TKey, TRecord>? collection = null;
using (StreamReader streamReader = new(stream))
{
string result = streamReader.ReadToEnd();
var recordCollection = JsonSerializer.Deserialize<InMemoryRecordCollection<TKey, InMemoryRecordWrapper<TRecord>>>(result);
if (recordCollection is null)
{
throw new InvalidOperationException("Stream does not contain valid | key |
csharp | abpframework__abp | modules/cms-kit/test/Volo.CmsKit.Domain.Tests/Blogs/BlogPostManager_Tests.cs | {
"start": 270,
"end": 2971
} | public class ____ : CmsKitDomainTestBase
{
private readonly BlogPostManager blogPostManager;
private readonly IGuidGenerator guidGenerator;
private readonly IBlogPostRepository blogPostRepository;
private readonly IBlogRepository blogRepository;
private readonly ICmsUserRepository userRepository;
private readonly CmsKitTestData cmsKitTestData;
public BlogPostManager_Tests()
{
blogPostManager = GetRequiredService<BlogPostManager>();
guidGenerator = GetRequiredService<IGuidGenerator>();
blogPostRepository = GetRequiredService<IBlogPostRepository>();
blogRepository = GetRequiredService<IBlogRepository>();
cmsKitTestData = GetRequiredService<CmsKitTestData>();
userRepository = GetRequiredService<ICmsUserRepository>();
}
[Fact]
public async Task CreateAsync_ShouldWorkProperly_WithExistingUserAndBlog()
{
var title = "New blog post";
var slug = "new-blog-post";
var author = await userRepository.GetAsync(cmsKitTestData.User1Id);
var blog = await blogRepository.GetAsync(cmsKitTestData.Blog_Id);
var blogPost = await blogPostManager.CreateAsync(author, blog, title, slug, BlogPostStatus.Published);
blogPost.Id.ShouldNotBe(Guid.Empty);
blogPost.Title.ShouldBe(title);
blogPost.Slug.ShouldBe(slug);
}
[Fact]
public async Task CreateAsync_ShouldThrowException_WhenSlugAlreadyExists()
{
var author = await userRepository.GetAsync(cmsKitTestData.User1Id);
var blog = await blogRepository.GetAsync(cmsKitTestData.Blog_Id);
await Should.ThrowAsync<BlogPostSlugAlreadyExistException>(async () =>
await blogPostManager.CreateAsync(author, blog, "Any New Title", cmsKitTestData.BlogPost_1_Slug, BlogPostStatus.Published));
}
[Fact]
public async Task SetSlugAsync_ShouldWorkProperly_WithNonExistingSlug()
{
var newSlug = "yet-another-post";
var blogPost = await blogPostRepository.GetAsync(cmsKitTestData.BlogPost_1_Id);
await blogPostManager.SetSlugUrlAsync(blogPost, newSlug);
blogPost.Slug.ShouldBe(newSlug);
}
[Fact]
public async Task SetSlugAsync_ShouldThrowException_WithExistingSlug()
{
var blogPost = await blogPostRepository.GetAsync(cmsKitTestData.BlogPost_1_Id);
var exception = await Should.ThrowAsync<BlogPostSlugAlreadyExistException>(async () =>
await blogPostManager.SetSlugUrlAsync(blogPost, cmsKitTestData.BlogPost_2_Slug));
exception.BlogId.ShouldBe(blogPost.BlogId);
exception.Slug.ShouldBe(cmsKitTestData.BlogPost_2_Slug);
}
}
| BlogPostManager_Tests |
csharp | dotnet__aspnetcore | src/Components/WebAssembly/DevServer/src/Server/Startup.cs | {
"start": 441,
"end": 5025
} | internal sealed class ____
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public static void ConfigureServices(IServiceCollection services)
{
services.AddRouting();
}
public static void Configure(IApplicationBuilder app, IConfiguration configuration)
{
app.UseDeveloperExceptionPage();
EnableConfiguredPathbase(app, configuration);
app.UseWebAssemblyDebugging();
var webHostEnvironment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
var applyCopHeaders = configuration.GetValue<bool>("ApplyCopHeaders");
app.Use(async (ctx, next) =>
{
if (ctx.Request.Path.StartsWithSegments("/_framework/blazor.boot.json"))
{
ctx.Response.Headers.Append("Blazor-Environment", webHostEnvironment.EnvironmentName);
}
else if (applyCopHeaders && ctx.Request.Path.StartsWithSegments("/_framework") && !ctx.Request.Path.StartsWithSegments("/_framework/blazor.server.js") && !ctx.Request.Path.StartsWithSegments("/_framework/blazor.web.js"))
{
var fileExtension = Path.GetExtension(ctx.Request.Path);
if (string.Equals(fileExtension, ".js", StringComparison.OrdinalIgnoreCase) || string.Equals(fileExtension, ".mjs", StringComparison.OrdinalIgnoreCase))
{
// Browser multi-threaded runtime requires cross-origin policy headers to enable SharedArrayBuffer.
ApplyCrossOriginPolicyHeaders(ctx);
}
}
await next(ctx);
});
app.UseRouting();
app.UseStaticFiles(new StaticFileOptions
{
// In development, serve everything, as there's no other way to configure it.
// In production, developers are responsible for configuring their own production server
ServeUnknownFileTypes = true,
});
app.UseEndpoints(endpoints =>
{
var manifest = configuration["staticAssets"]!;
endpoints.MapStaticAssets(manifest);
endpoints.MapFallbackToFile("index.html", new StaticFileOptions
{
OnPrepareResponse = fileContext =>
{
// Avoid caching index.html during development.
// When hot reload is enabled, a middleware injects a hot reload script into the response HTML.
// We don't want the browser to bypass this injection by using a cached response that doesn't
// contain the injected script. In the future, if script injection is removed in favor of a
// different mechanism, we can delete this comment and the line below it.
// See also: https://github.com/dotnet/aspnetcore/issues/45213
fileContext.Context.Response.Headers[HeaderNames.CacheControl] = "no-store";
if (applyCopHeaders)
{
// Browser multi-threaded runtime requires cross-origin policy headers to enable SharedArrayBuffer.
ApplyCrossOriginPolicyHeaders(fileContext.Context);
}
}
});
});
}
private static void EnableConfiguredPathbase(IApplicationBuilder app, IConfiguration configuration)
{
var pathBase = configuration.GetValue<string>("pathbase");
if (!string.IsNullOrEmpty(pathBase))
{
app.UsePathBase(pathBase);
// To ensure consistency with a production environment, only handle requests
// that match the specified pathbase.
app.Use((context, next) =>
{
if (context.Request.PathBase == pathBase)
{
return next(context);
}
else
{
context.Response.StatusCode = 404;
return context.Response.WriteAsync($"The server is configured only to " +
$"handle request URIs within the PathBase '{pathBase}'.");
}
});
}
}
private static void ApplyCrossOriginPolicyHeaders(HttpContext httpContext)
{
httpContext.Response.Headers["Cross-Origin-Embedder-Policy"] = "require-corp";
httpContext.Response.Headers["Cross-Origin-Opener-Policy"] = "same-origin";
}
}
| Startup |
csharp | bitwarden__server | src/Api/KeyManagement/Models/Requests/MasterPasswordAuthenticationDataRequestModel.cs | {
"start": 139,
"end": 674
} | public class ____
{
public required KdfRequestModel Kdf { get; init; }
public required string MasterPasswordAuthenticationHash { get; init; }
[StringLength(256)] public required string Salt { get; init; }
public MasterPasswordAuthenticationData ToData()
{
return new MasterPasswordAuthenticationData
{
Kdf = Kdf.ToData(),
MasterPasswordAuthenticationHash = MasterPasswordAuthenticationHash,
Salt = Salt
};
}
}
| MasterPasswordAuthenticationDataRequestModel |
csharp | dotnet__aspnetcore | src/Components/WebAssembly/WebAssembly.Authentication/src/Services/SignOutSessionStateManager.cs | {
"start": 3531,
"end": 3704
} | private struct ____
{
public static readonly SignOutState Instance = new SignOutState { Local = true };
public bool Local { get; set; }
}
}
| SignOutState |
csharp | nopSolutions__nopCommerce | src/Presentation/Nop.Web/Areas/Admin/Factories/ICommonModelFactory.cs | {
"start": 1912,
"end": 2095
} | record ____ model
/// </returns>
Task<UrlRecordSearchModel> PrepareUrlRecordSearchModelAsync(UrlRecordSearchModel searchModel);
/// <summary>
/// Prepare paged URL | search |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Core/src/Types/Types/Descriptors/InputObjectTypeDescriptor.cs | {
"start": 289,
"end": 7643
} | public class ____
: DescriptorBase<InputObjectTypeConfiguration>
, IInputObjectTypeDescriptor
{
private readonly List<InputFieldDescriptor> _fields = [];
protected InputObjectTypeDescriptor(IDescriptorContext context, Type runtimeType)
: base(context)
{
ArgumentNullException.ThrowIfNull(runtimeType);
Configuration.RuntimeType = runtimeType;
Configuration.Name = context.Naming.GetTypeName(
runtimeType, TypeKind.InputObject);
Configuration.Description = context.Naming.GetTypeDescription(
runtimeType, TypeKind.InputObject);
}
protected InputObjectTypeDescriptor(IDescriptorContext context)
: base(context)
{
Configuration.RuntimeType = typeof(object);
}
protected InputObjectTypeDescriptor(
IDescriptorContext context,
InputObjectTypeConfiguration definition)
: base(context)
{
Configuration = definition ?? throw new ArgumentNullException(nameof(definition));
foreach (var field in definition.Fields)
{
_fields.Add(InputFieldDescriptor.From(Context, field));
}
}
protected internal override InputObjectTypeConfiguration Configuration { get; protected set; } =
new();
protected ICollection<InputFieldDescriptor> Fields => _fields;
protected override void OnCreateConfiguration(
InputObjectTypeConfiguration definition)
{
Context.Descriptors.Push(this);
if (!Configuration.ConfigurationsAreApplied)
{
DescriptorAttributeHelper.ApplyConfiguration(
Context,
this,
Configuration.RuntimeType);
Configuration.ConfigurationsAreApplied = true;
}
var fields = TypeMemHelper.RentInputFieldConfigurationMap();
var handledMembers = TypeMemHelper.RentMemberSet();
foreach (var fieldDescriptor in _fields)
{
var fieldDefinition = fieldDescriptor.CreateConfiguration();
if (!fieldDefinition.Ignore && !string.IsNullOrEmpty(fieldDefinition.Name))
{
fields[fieldDefinition.Name] = fieldDefinition;
}
if (fieldDefinition.Property is { } prop)
{
handledMembers.Add(prop);
}
}
OnCompleteFields(fields, handledMembers);
Configuration.Fields.Clear();
Configuration.Fields.AddRange(fields.Values);
TypeMemHelper.Return(fields);
TypeMemHelper.Return(handledMembers);
base.OnCreateConfiguration(definition);
Context.Descriptors.Pop();
}
protected void InferFieldsFromFieldBindingType(
IDictionary<string, InputFieldConfiguration> fields,
ISet<MemberInfo> handledMembers)
{
if (Configuration.Fields.IsImplicitBinding())
{
var inspector = Context.TypeInspector;
var naming = Context.Naming;
var type = Configuration.RuntimeType;
var members = inspector.GetMembers(type);
foreach (var member in members)
{
if (member is PropertyInfo propertyInfo
&& (propertyInfo.CanWrite || HasConstructorParameter(type, propertyInfo)))
{
var name = naming.GetMemberName(propertyInfo, MemberKind.InputObjectField);
if (handledMembers.Add(propertyInfo)
&& !fields.ContainsKey(name))
{
var descriptor = InputFieldDescriptor.New(Context, propertyInfo);
_fields.Add(descriptor);
handledMembers.Add(propertyInfo);
// the create definition call will trigger the OnCompleteField call
// on the field description and trigger the initialization of the
// fields arguments.
fields[name] = descriptor.CreateConfiguration();
}
}
}
}
}
protected virtual void OnCompleteFields(
IDictionary<string, InputFieldConfiguration> fields,
ISet<MemberInfo> handledMembers)
{ }
public IInputObjectTypeDescriptor Name(string value)
{
Configuration.Name = value;
return this;
}
public IInputObjectTypeDescriptor Description(string value)
{
Configuration.Description = value;
return this;
}
public IInputFieldDescriptor Field(string name)
{
var fieldDescriptor = _fields.Find(t => t.Configuration.Name.EqualsOrdinal(name));
if (fieldDescriptor is not null)
{
return fieldDescriptor;
}
fieldDescriptor = new InputFieldDescriptor(Context, name);
_fields.Add(fieldDescriptor);
return fieldDescriptor;
}
public IInputObjectTypeDescriptor Directive<T>(T directive)
where T : class
{
Configuration.AddDirective(directive, Context.TypeInspector);
return this;
}
public IInputObjectTypeDescriptor Directive<T>()
where T : class, new()
{
Configuration.AddDirective(new T(), Context.TypeInspector);
return this;
}
public IInputObjectTypeDescriptor Directive(
string name,
params ArgumentNode[] arguments)
{
Configuration.AddDirective(name, arguments);
return this;
}
public static InputObjectTypeDescriptor New(IDescriptorContext context) => new(context);
public static InputObjectTypeDescriptor New(IDescriptorContext context, Type clrType)
=> new(context, clrType);
public static InputObjectTypeDescriptor<T> New<T>(IDescriptorContext context) => new(context);
public static InputObjectTypeDescriptor FromSchemaType(
IDescriptorContext context,
Type schemaType)
{
var descriptor = New(context, schemaType);
descriptor.Configuration.RuntimeType = typeof(object);
return descriptor;
}
public static InputObjectTypeDescriptor From(
IDescriptorContext context,
InputObjectTypeConfiguration definition)
=> new(context, definition);
public static InputObjectTypeDescriptor<T> From<T>(
IDescriptorContext context,
InputObjectTypeConfiguration definition)
=> new(context, definition);
/// <summary>
/// Gets a value indicating whether the specified type contains a constructor parameter with the
/// same (case-insensitive) name and type as the specified property.
/// </summary>
/// <param name="type">The type to check for a matching constructor parameter.</param>
/// <param name="property">The property to compare with constructor parameters.</param>
/// <returns>
/// <c>true</c> if a matching constructor parameter exists; otherwise, <c>false</c>.
/// </returns>
private static bool HasConstructorParameter(Type type, PropertyInfo property)
{
return type.GetConstructors(NonPublic | Public | Instance).Any(
c => c.GetParameters().Any(
p => p.Name.EqualsInvariantIgnoreCase(property.Name)
&& p.ParameterType == property.PropertyType));
}
}
| InputObjectTypeDescriptor |
csharp | dotnet__aspire | tests/Aspire.Hosting.Tests/DistributedApplicationBuilderTests.cs | {
"start": 632,
"end": 9761
} | public class ____
{
[Theory]
[InlineData(new string[0], DistributedApplicationOperation.Run)]
[InlineData(new string[] { "--publisher", "manifest" }, DistributedApplicationOperation.Publish)]
public void BuilderExecutionContextExposesCorrectOperation(string[] args, DistributedApplicationOperation operation)
{
var builder = DistributedApplication.CreateBuilder(args);
Assert.Equal(operation, builder.ExecutionContext.Operation);
}
[Fact]
public void BuilderAddsDefaultServices()
{
var appBuilder = DistributedApplication.CreateBuilder();
appBuilder.Services.Configure<DcpOptions>(o =>
{
o.DashboardPath = "dashboard";
o.CliPath = "dcp";
});
using var app = appBuilder.Build();
var appModel = app.Services.GetRequiredService<DistributedApplicationModel>();
Assert.Empty(appModel.Resources);
var eventingSubscribers = app.Services.GetServices<IDistributedApplicationEventingSubscriber>();
Assert.Collection(
eventingSubscribers,
s => Assert.IsType<DashboardEventHandlers>(s),
s => Assert.IsType<DevcontainerPortForwardingLifecycleHook>(s)
);
var options = app.Services.GetRequiredService<IOptions<PipelineOptions>>();
Assert.Null(options.Value.OutputPath);
}
[Fact]
public void BuilderAddsResourceToAddModel()
{
var appBuilder = DistributedApplication.CreateBuilder();
appBuilder.AddResource(new TestResource());
using var app = appBuilder.Build();
var appModel = app.Services.GetRequiredService<DistributedApplicationModel>();
var resource = Assert.Single(appModel.Resources);
Assert.IsType<TestResource>(resource);
}
[Fact]
public void BuilderConfiguresPublishingOptionsFromCommandLine()
{
var appBuilder = DistributedApplication.CreateBuilder(["--publisher", "manifest", "--output-path", "/tmp/"]);
using var app = appBuilder.Build();
var pipelineOptions = app.Services.GetRequiredService<IOptions<PipelineOptions>>();
Assert.Equal("/tmp/", pipelineOptions.Value.OutputPath);
}
[Fact]
public void BuilderConfiguresPublishingOptionsFromConfig()
{
var appBuilder = DistributedApplication.CreateBuilder(["--publisher", "manifest", "--output-path", "/tmp/"]);
appBuilder.Configuration["Pipeline:OutputPath"] = "/path/";
using var app = appBuilder.Build();
var pipelineOptions = app.Services.GetRequiredService<IOptions<PipelineOptions>>();
Assert.Equal("/path/", pipelineOptions.Value.OutputPath);
}
[Fact]
public void AppHostDirectoryAvailableViaConfig()
{
var appBuilder = DistributedApplication.CreateBuilder();
var appHostDirectory = appBuilder.AppHostDirectory;
using var app = appBuilder.Build();
var config = app.Services.GetRequiredService<IConfiguration>();
Assert.Equal(appHostDirectory, config["AppHost:Directory"]);
}
[Fact]
public void ResourceServiceConfig_Secured()
{
var appBuilder = DistributedApplication.CreateBuilder();
using var app = appBuilder.Build();
var config = app.Services.GetRequiredService<IConfiguration>();
Assert.Equal(nameof(ResourceServiceAuthMode.ApiKey), config["AppHost:ResourceService:AuthMode"]);
Assert.False(string.IsNullOrEmpty(config["AppHost:ResourceService:ApiKey"]));
}
[Theory]
[InlineData(KnownConfigNames.DashboardUnsecuredAllowAnonymous)]
[InlineData(KnownConfigNames.Legacy.DashboardUnsecuredAllowAnonymous)]
public void ResourceServiceConfig_Unsecured(string dashboardUnsecuredAllowAnonymousKey)
{
var appBuilder = DistributedApplication.CreateBuilder(args: [$"{dashboardUnsecuredAllowAnonymousKey}=true"]);
using var app = appBuilder.Build();
var config = app.Services.GetRequiredService<IConfiguration>();
Assert.Equal(nameof(ResourceServiceAuthMode.Unsecured), config["AppHost:ResourceService:AuthMode"]);
Assert.True(string.IsNullOrEmpty(config["AppHost:ResourceService:ApiKey"]));
}
[Fact]
public void AddResource_DuplicateResourceNames_SameCasing_Error()
{
var appBuilder = DistributedApplication.CreateBuilder();
appBuilder.AddResource(new ContainerResource("Test"));
var ex = Assert.Throws<DistributedApplicationException>(() => appBuilder.AddResource(new ContainerResource("Test")));
Assert.Equal("Cannot add resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with name 'Test' because resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with that name already exists. Resource names are case-insensitive.", ex.Message);
}
[Fact]
public void AddResource_DuplicateResourceNames_MixedCasing_Error()
{
var appBuilder = DistributedApplication.CreateBuilder();
appBuilder.AddResource(new ContainerResource("Test"));
var ex = Assert.Throws<DistributedApplicationException>(() => appBuilder.AddResource(new ContainerResource("TEST")));
Assert.Equal("Cannot add resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with name 'TEST' because resource of type 'Aspire.Hosting.ApplicationModel.ContainerResource' with that name already exists. Resource names are case-insensitive.", ex.Message);
}
[Fact]
public void Build_DuplicateResourceNames_MixedCasing_Error()
{
var appBuilder = DistributedApplication.CreateBuilder();
appBuilder.Resources.Add(new ContainerResource("Test"));
appBuilder.Resources.Add(new ContainerResource("Test"));
var ex = Assert.Throws<DistributedApplicationException>(appBuilder.Build);
Assert.Equal("Multiple resources with the name 'Test'. Resource names are case-insensitive.", ex.Message);
}
[Fact]
public void Build_DuplicateResourceNames_SameCasing_Error()
{
var appBuilder = DistributedApplication.CreateBuilder();
appBuilder.Resources.Add(new ContainerResource("Test"));
appBuilder.Resources.Add(new ContainerResource("TEST"));
var ex = Assert.Throws<DistributedApplicationException>(appBuilder.Build);
Assert.Equal("Multiple resources with the name 'Test'. Resource names are case-insensitive.", ex.Message);
}
[Fact]
public void PathShaAndProjectNameShaBothAvailable()
{
var appBuilder = DistributedApplication.CreateBuilder();
var pathSha = appBuilder.Configuration["AppHost:PathSha256"];
var projectNameSha = appBuilder.Configuration["AppHost:ProjectNameSha256"];
var legacySha = appBuilder.Configuration["AppHost:Sha256"];
// Verify all three SHA values are available
Assert.NotNull(pathSha);
Assert.NotNull(projectNameSha);
Assert.NotNull(legacySha);
// In run mode, legacy SHA should equal PathSha
Assert.False(appBuilder.ExecutionContext.IsPublishMode);
Assert.Equal(pathSha, legacySha);
}
[Fact]
public void PathShaDiffersForDifferentPaths()
{
var options1 = new DistributedApplicationOptions
{
ProjectDirectory = "/home/user/project1",
ProjectName = "TestApp",
Args = []
};
var options2 = new DistributedApplicationOptions
{
ProjectDirectory = "/home/user/project2",
ProjectName = "TestApp", // Same name, different path
Args = []
};
var builder1 = (DistributedApplicationBuilder)DistributedApplication.CreateBuilder(options1);
var builder2 = (DistributedApplicationBuilder)DistributedApplication.CreateBuilder(options2);
var pathSha1 = builder1.Configuration["AppHost:PathSha256"];
var pathSha2 = builder2.Configuration["AppHost:PathSha256"];
var projectNameSha1 = builder1.Configuration["AppHost:ProjectNameSha256"];
var projectNameSha2 = builder2.Configuration["AppHost:ProjectNameSha256"];
// PathSha should differ for different paths
Assert.NotEqual(pathSha1, pathSha2);
// ProjectNameSha should be the same for same project name
Assert.Equal(projectNameSha1, projectNameSha2);
}
[Fact]
public void LegacyShaUsesProjectNameShaInPublishMode()
{
var appBuilder = DistributedApplication.CreateBuilder(["--publisher", "manifest"]);
var pathSha = appBuilder.Configuration["AppHost:PathSha256"];
var projectNameSha = appBuilder.Configuration["AppHost:ProjectNameSha256"];
var legacySha = appBuilder.Configuration["AppHost:Sha256"];
// Verify all three SHA values are available
Assert.NotNull(pathSha);
Assert.NotNull(projectNameSha);
Assert.NotNull(legacySha);
// In publish mode, legacy SHA should equal ProjectNameSha
Assert.True(appBuilder.ExecutionContext.IsPublishMode);
Assert.Equal(projectNameSha, legacySha);
}
| DistributedApplicationBuilderTests |
csharp | dotnet__maui | src/Core/src/Platform/Tizen/ButtonExtensions.cs | {
"start": 101,
"end": 1574
} | public static class ____
{
public static void UpdateTextColor(this Button platformButton, ITextStyle button)
{
platformButton.TextColor = button.TextColor.ToPlatform();
}
public static void UpdateText(this Button platformButton, IText button)
{
platformButton.Text = button.Text ?? "";
}
public static void UpdateCharacterSpacing(this Button platformButton, ITextStyle button)
{
platformButton.TextLabel.CharacterSpacing = button.CharacterSpacing.ToScaledPixel();
}
public static void UpdateFont(this Button platformButton, ITextStyle label, IFontManager fontManager)
{
platformButton.FontSize = label.Font.Size > 0 ? label.Font.Size.ToScaledPoint() : 14d.ToScaledPoint();
platformButton.FontAttributes = label.Font.GetFontAttributes();
platformButton.FontFamily = fontManager.GetFontFamily(label.Font.Family) ?? "";
}
public static void UpdateStrokeColor(this Button platformButton, IButtonStroke button)
{
platformButton.BorderlineColor = button.StrokeColor.ToNUIColor() ?? NColor.Transparent;
}
public static void UpdateStrokeThickness(this Button platformButton, IButtonStroke button)
{
platformButton.BorderlineWidth = button.StrokeThickness.ToScaledPixel();
}
public static void UpdateCornerRadius(this Button platformButton, IButtonStroke button)
{
if (button.CornerRadius != -1)
{
platformButton.CornerRadius = ((double)button.CornerRadius).ToScaledPixel();
}
}
}
}
| ButtonExtensions |
csharp | dotnet__aspnetcore | src/SignalR/common/SignalR.Common/src/Protocol/HandshakeProtocol.cs | {
"start": 413,
"end": 472
} | class ____ working with SignalR handshakes.
/// </summary>
| for |
csharp | dotnet__maui | src/Controls/tests/Xaml.UnitTests/Issues/Gh7097.xaml.cs | {
"start": 286,
"end": 1291
} | class ____
{
[SetUp] public void Setup() => DispatcherProvider.SetCurrent(new DispatcherProviderStub());
[TearDown] public void TearDown() => DispatcherProvider.SetCurrent(null);
[Test]
public void CanXReferenceRoot([Values] XamlInflator inflator)
{
var layout = new Gh7097(inflator)
{
BindingContext = new
{
Button1Command = new MockCommand(),
Button2Command = new MockCommand(),
}
};
var cv = layout.Content as CollectionView;
var content = cv.ItemTemplate.CreateContent() as StackLayout;
var btn1 = content.Children[0] as Button;
Assert.That(btn1.Command, Is.TypeOf<MockCommand>());
}
[Test]
//this was later reported as https://github.com/xamarin/Microsoft.Maui.Controls/issues/7286
public void RegisteringXNameOnSubPages([Values] XamlInflator inflator)
{
var layout = new Gh7097(inflator);
var s = layout.FindByName("self");
Assert.That(layout.self, Is.Not.Null);
Assert.That(layout.collectionview, Is.Not.Null);
}
| Tests |
csharp | nopSolutions__nopCommerce | src/Presentation/Nop.Web/Areas/Admin/Models/Common/MultistorePreviewModel.cs | {
"start": 80,
"end": 222
} | public partial record ____ : BaseNopModel
{
public string StoreName { get; set; }
public string Url { get; set; }
}
| MultistorePreviewModel |
csharp | ShareX__ShareX | ShareX/LanguageHelper.cs | {
"start": 1223,
"end": 9811
} | public static class ____
{
public static bool ChangeLanguage(SupportedLanguage language, params Form[] forms)
{
CultureInfo currentCulture;
if (language == SupportedLanguage.Automatic)
{
currentCulture = CultureInfo.InstalledUICulture;
}
else
{
string cultureName = GetCultureName(language);
currentCulture = CultureInfo.GetCultureInfo(cultureName);
}
if (!currentCulture.Equals(Thread.CurrentThread.CurrentUICulture))
{
Helpers.SetDefaultUICulture(currentCulture);
DebugHelper.WriteLine("Language changed to: " + currentCulture.DisplayName);
foreach (Form form in forms)
{
ComponentResourceManager resources = new ComponentResourceManager(form.GetType());
ApplyResourceToControl(form, resources, currentCulture);
resources.ApplyResources(form, "$this", currentCulture);
}
return true;
}
return false;
}
public static Image GetLanguageIcon(SupportedLanguage language)
{
Image icon;
switch (language)
{
default:
case SupportedLanguage.Automatic:
icon = Resources.globe;
break;
case SupportedLanguage.Arabic:
icon = Resources.ye;
break;
case SupportedLanguage.Dutch:
icon = Resources.nl;
break;
case SupportedLanguage.English:
icon = Resources.us;
break;
case SupportedLanguage.French:
icon = Resources.fr;
break;
case SupportedLanguage.German:
icon = Resources.de;
break;
case SupportedLanguage.Hebrew:
icon = Resources.il;
break;
case SupportedLanguage.Hungarian:
icon = Resources.hu;
break;
case SupportedLanguage.Indonesian:
icon = Resources.id;
break;
case SupportedLanguage.Italian:
icon = Resources.it;
break;
case SupportedLanguage.Japanese:
icon = Resources.jp;
break;
case SupportedLanguage.Korean:
icon = Resources.kr;
break;
case SupportedLanguage.MexicanSpanish:
icon = Resources.mx;
break;
case SupportedLanguage.Persian:
icon = Resources.ir;
break;
case SupportedLanguage.Polish:
icon = Resources.pl;
break;
case SupportedLanguage.Portuguese:
icon = Resources.pt;
break;
case SupportedLanguage.PortugueseBrazil:
icon = Resources.br;
break;
case SupportedLanguage.Romanian:
icon = Resources.ro;
break;
case SupportedLanguage.Russian:
icon = Resources.ru;
break;
case SupportedLanguage.SimplifiedChinese:
icon = Resources.cn;
break;
case SupportedLanguage.Spanish:
icon = Resources.es;
break;
case SupportedLanguage.TraditionalChinese:
icon = Resources.tw;
break;
case SupportedLanguage.Turkish:
icon = Resources.tr;
break;
case SupportedLanguage.Ukrainian:
icon = Resources.ua;
break;
case SupportedLanguage.Vietnamese:
icon = Resources.vn;
break;
}
return icon;
}
public static string GetCultureName(SupportedLanguage language)
{
string cultureName;
switch (language)
{
case SupportedLanguage.Arabic:
cultureName = "ar-YE";
break;
case SupportedLanguage.Dutch:
cultureName = "nl-NL";
break;
default:
case SupportedLanguage.English:
cultureName = "en-US";
break;
case SupportedLanguage.French:
cultureName = "fr-FR";
break;
case SupportedLanguage.German:
cultureName = "de-DE";
break;
case SupportedLanguage.Hebrew:
cultureName = "he-IL";
break;
case SupportedLanguage.Hungarian:
cultureName = "hu-HU";
break;
case SupportedLanguage.Indonesian:
cultureName = "id-ID";
break;
case SupportedLanguage.Italian:
cultureName = "it-IT";
break;
case SupportedLanguage.Japanese:
cultureName = "ja-JP";
break;
case SupportedLanguage.Korean:
cultureName = "ko-KR";
break;
case SupportedLanguage.MexicanSpanish:
cultureName = "es-MX";
break;
case SupportedLanguage.Persian:
cultureName = "fa-IR";
break;
case SupportedLanguage.Polish:
cultureName = "pl-PL";
break;
case SupportedLanguage.Portuguese:
cultureName = "pt-PT";
break;
case SupportedLanguage.PortugueseBrazil:
cultureName = "pt-BR";
break;
case SupportedLanguage.Romanian:
cultureName = "ro-RO";
break;
case SupportedLanguage.Russian:
cultureName = "ru-RU";
break;
case SupportedLanguage.SimplifiedChinese:
cultureName = "zh-CN";
break;
case SupportedLanguage.Spanish:
cultureName = "es-ES";
break;
case SupportedLanguage.TraditionalChinese:
cultureName = "zh-TW";
break;
case SupportedLanguage.Turkish:
cultureName = "tr-TR";
break;
case SupportedLanguage.Ukrainian:
cultureName = "uk-UA";
break;
case SupportedLanguage.Vietnamese:
cultureName = "vi-VN";
break;
}
return cultureName;
}
private static void ApplyResourceToControl(Control control, ComponentResourceManager resource, CultureInfo culture)
{
if (control is ToolStrip ts)
{
ApplyResourceToToolStripItemCollection(ts.Items, resource, culture);
}
else
{
foreach (Control child in control.Controls)
{
ApplyResourceToControl(child, resource, culture);
}
}
resource.ApplyResources(control, control.Name, culture);
}
private static void ApplyResourceToToolStripItemCollection(ToolStripItemCollection collection, ComponentResourceManager resource, CultureInfo culture)
{
foreach (ToolStripItem item in collection)
{
if (item is ToolStripDropDownItem tsddi)
{
ApplyResourceToToolStripItemCollection(tsddi.DropDownItems, resource, culture);
}
resource.ApplyResources(item, item.Name, culture);
}
}
}
} | LanguageHelper |
csharp | cake-build__cake | src/Cake.Common.Tests/Unit/Tools/MSBuild/MSBuildSettingsTests.cs | {
"start": 1332,
"end": 1761
} | public sealed class ____
{
[Fact]
public void Should_Return_A_Set_That_Is_Case_Insensitive()
{
// Given
var settings = new MSBuildSettings();
// When
settings.Targets.Add("TARGET");
// Then
Assert.True(settings.Targets.Contains("target"));
}
}
| TheTargetsProperty |
csharp | CommunityToolkit__dotnet | tests/CommunityToolkit.Mvvm.SourceGenerators.Roslyn4120.UnitTests/Test_UsePartialPropertyForObservablePropertyCodeFixer.cs | {
"start": 9565,
"end": 9828
} | public class ____(string text) : Attribute;
""";
string @fixed = """
using System;
using System.ComponentModel.DataAnnotations;
using CommunityToolkit.Mvvm.ComponentModel;
| TestAttribute |
csharp | MonoGame__MonoGame | MonoGame.Framework/Graphics/Effect/EffectPass.cs | {
"start": 236,
"end": 5228
} | public class ____
{
private readonly Effect _effect;
private readonly Shader _pixelShader;
private readonly Shader _vertexShader;
private readonly BlendState _blendState;
private readonly DepthStencilState _depthStencilState;
private readonly RasterizerState _rasterizerState;
/// <summary>
/// Gets the name of this pass.
/// </summary>
public string Name { get; private set; }
/// <summary>
/// Gets the collection of <see cref="EffectAnnotation"/> objects for this <see cref="EffectPass"/>.
/// </summary>
public EffectAnnotationCollection Annotations { get; private set; }
internal EffectPass( Effect effect,
string name,
Shader vertexShader,
Shader pixelShader,
BlendState blendState,
DepthStencilState depthStencilState,
RasterizerState rasterizerState,
EffectAnnotationCollection annotations )
{
Debug.Assert(effect != null, "Got a null effect!");
Debug.Assert(annotations != null, "Got a null annotation collection!");
_effect = effect;
Name = name;
_vertexShader = vertexShader;
_pixelShader = pixelShader;
_blendState = blendState;
_depthStencilState = depthStencilState;
_rasterizerState = rasterizerState;
Annotations = annotations;
}
internal EffectPass(Effect effect, EffectPass cloneSource)
{
Debug.Assert(effect != null, "Got a null effect!");
Debug.Assert(cloneSource != null, "Got a null cloneSource!");
_effect = effect;
// Share all the immutable types.
Name = cloneSource.Name;
_blendState = cloneSource._blendState;
_depthStencilState = cloneSource._depthStencilState;
_rasterizerState = cloneSource._rasterizerState;
Annotations = cloneSource.Annotations;
_vertexShader = cloneSource._vertexShader;
_pixelShader = cloneSource._pixelShader;
}
/// <summary>
/// Begins this pass.
/// </summary>
public void Apply()
{
// Set/get the correct shader handle/cleanups.
var current = _effect.CurrentTechnique;
_effect.OnApply();
if (_effect.CurrentTechnique != current)
{
_effect.CurrentTechnique.Passes[0].Apply();
return;
}
var device = _effect.GraphicsDevice;
if (_vertexShader != null)
{
device.VertexShader = _vertexShader;
// Update the texture parameters.
SetShaderSamplers(_vertexShader, device.VertexTextures, device.VertexSamplerStates);
// Update the constant buffers.
for (var c = 0; c < _vertexShader.CBuffers.Length; c++)
{
var cb = _effect.ConstantBuffers[_vertexShader.CBuffers[c]];
cb.Update(_effect.Parameters);
device.SetConstantBuffer(ShaderStage.Vertex, c, cb);
}
}
if (_pixelShader != null)
{
device.PixelShader = _pixelShader;
// Update the texture parameters.
SetShaderSamplers(_pixelShader, device.Textures, device.SamplerStates);
// Update the constant buffers.
for (var c = 0; c < _pixelShader.CBuffers.Length; c++)
{
var cb = _effect.ConstantBuffers[_pixelShader.CBuffers[c]];
cb.Update(_effect.Parameters);
device.SetConstantBuffer(ShaderStage.Pixel, c, cb);
}
}
// Set the render states if we have some.
if (_rasterizerState != null)
device.RasterizerState = _rasterizerState;
if (_blendState != null)
device.BlendState = _blendState;
if (_depthStencilState != null)
device.DepthStencilState = _depthStencilState;
}
private void SetShaderSamplers(Shader shader, TextureCollection textures, SamplerStateCollection samplerStates)
{
foreach (var sampler in shader.Samplers)
{
var param = _effect.Parameters[sampler.parameter];
var texture = param.Data as Texture;
textures[sampler.textureSlot] = texture;
// If there is a sampler state set it.
if (sampler.state != null)
samplerStates[sampler.samplerSlot] = sampler.state;
}
}
}
} | EffectPass |
csharp | JamesNK__Newtonsoft.Json | Src/Newtonsoft.Json.Tests/TestObjects/PrivateImplementationAClass.cs | {
"start": 1203,
"end": 1533
} | public class ____ : IPrivateImplementationA
{
[JsonIgnore]
public string PropertyA { get; set; }
[JsonProperty("PropertyA")]
string IPrivateImplementationA.PropertyA
{
get { return PropertyA; }
set { PropertyA = value; }
}
}
} | PrivateImplementationAClass |
csharp | nopSolutions__nopCommerce | src/Presentation/Nop.Web/Areas/Admin/Models/Settings/SettingSearchModel.cs | {
"start": 191,
"end": 748
} | public partial record ____ : BaseSearchModel
{
#region Ctor
public SettingSearchModel()
{
AddSetting = new SettingModel();
}
#endregion
#region Properties
[NopResourceDisplayName("Admin.Configuration.Settings.AllSettings.SearchSettingName")]
public string SearchSettingName { get; set; }
[NopResourceDisplayName("Admin.Configuration.Settings.AllSettings.SearchSettingValue")]
public string SearchSettingValue { get; set; }
public SettingModel AddSetting { get; set; }
#endregion
} | SettingSearchModel |
csharp | nuke-build__nuke | source/Nuke.Common/Tools/Docker/Docker.Generated.cs | {
"start": 2195917,
"end": 2203407
} | partial class ____
{
#region All
/// <inheritdoc cref="DockerStatsSettings.All"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.All))]
public static T SetAll<T>(this T o, bool? v) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.All, v));
/// <inheritdoc cref="DockerStatsSettings.All"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.All))]
public static T ResetAll<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Remove(() => o.All));
/// <inheritdoc cref="DockerStatsSettings.All"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.All))]
public static T EnableAll<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.All, true));
/// <inheritdoc cref="DockerStatsSettings.All"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.All))]
public static T DisableAll<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.All, false));
/// <inheritdoc cref="DockerStatsSettings.All"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.All))]
public static T ToggleAll<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.All, !o.All));
#endregion
#region Format
/// <inheritdoc cref="DockerStatsSettings.Format"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Format))]
public static T SetFormat<T>(this T o, string v) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.Format, v));
/// <inheritdoc cref="DockerStatsSettings.Format"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Format))]
public static T ResetFormat<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Remove(() => o.Format));
#endregion
#region NoStream
/// <inheritdoc cref="DockerStatsSettings.NoStream"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoStream))]
public static T SetNoStream<T>(this T o, bool? v) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoStream, v));
/// <inheritdoc cref="DockerStatsSettings.NoStream"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoStream))]
public static T ResetNoStream<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Remove(() => o.NoStream));
/// <inheritdoc cref="DockerStatsSettings.NoStream"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoStream))]
public static T EnableNoStream<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoStream, true));
/// <inheritdoc cref="DockerStatsSettings.NoStream"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoStream))]
public static T DisableNoStream<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoStream, false));
/// <inheritdoc cref="DockerStatsSettings.NoStream"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoStream))]
public static T ToggleNoStream<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoStream, !o.NoStream));
#endregion
#region NoTrunc
/// <inheritdoc cref="DockerStatsSettings.NoTrunc"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoTrunc))]
public static T SetNoTrunc<T>(this T o, bool? v) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoTrunc, v));
/// <inheritdoc cref="DockerStatsSettings.NoTrunc"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoTrunc))]
public static T ResetNoTrunc<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Remove(() => o.NoTrunc));
/// <inheritdoc cref="DockerStatsSettings.NoTrunc"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoTrunc))]
public static T EnableNoTrunc<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoTrunc, true));
/// <inheritdoc cref="DockerStatsSettings.NoTrunc"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoTrunc))]
public static T DisableNoTrunc<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoTrunc, false));
/// <inheritdoc cref="DockerStatsSettings.NoTrunc"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.NoTrunc))]
public static T ToggleNoTrunc<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.NoTrunc, !o.NoTrunc));
#endregion
#region Containers
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T SetContainers<T>(this T o, params string[] v) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.Containers, v));
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T SetContainers<T>(this T o, IEnumerable<string> v) where T : DockerStatsSettings => o.Modify(b => b.Set(() => o.Containers, v));
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T AddContainers<T>(this T o, params string[] v) where T : DockerStatsSettings => o.Modify(b => b.AddCollection(() => o.Containers, v));
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T AddContainers<T>(this T o, IEnumerable<string> v) where T : DockerStatsSettings => o.Modify(b => b.AddCollection(() => o.Containers, v));
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T RemoveContainers<T>(this T o, params string[] v) where T : DockerStatsSettings => o.Modify(b => b.RemoveCollection(() => o.Containers, v));
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T RemoveContainers<T>(this T o, IEnumerable<string> v) where T : DockerStatsSettings => o.Modify(b => b.RemoveCollection(() => o.Containers, v));
/// <inheritdoc cref="DockerStatsSettings.Containers"/>
[Pure] [Builder(Type = typeof(DockerStatsSettings), Property = nameof(DockerStatsSettings.Containers))]
public static T ClearContainers<T>(this T o) where T : DockerStatsSettings => o.Modify(b => b.ClearCollection(() => o.Containers));
#endregion
}
#endregion
#region DockerSearchSettingsExtensions
/// <inheritdoc cref="DockerTasks.DockerSearch(Nuke.Common.Tools.Docker.DockerSearchSettings)"/>
[PublicAPI]
[ExcludeFromCodeCoverage]
public static | DockerStatsSettingsExtensions |
csharp | microsoft__semantic-kernel | dotnet/src/IntegrationTests/CrossLanguage/KernelRequestTracer.cs | {
"start": 380,
"end": 449
} | class ____ trace the HTTP requests made by the kernel.
/// </summary>
| to |
csharp | aspnetboilerplate__aspnetboilerplate | src/Abp.Dapper/Dapper/Expressions/DapperExpressionExtensions.cs | {
"start": 181,
"end": 669
} | internal static class ____
{
[NotNull]
public static IPredicate ToPredicateGroup<TEntity, TPrimaryKey>([NotNull] this Expression<Func<TEntity, bool>> expression) where TEntity : class, IEntity<TPrimaryKey>
{
Check.NotNull(expression, nameof(expression));
var dev = new DapperExpressionVisitor<TEntity, TPrimaryKey>();
IPredicate pg = dev.Process(expression);
return pg;
}
}
}
| DapperExpressionExtensions |
csharp | DapperLib__Dapper | tests/Dapper.Tests/MultiMapTests.cs | {
"start": 4685,
"end": 13149
} | private class ____
{
public int Id { get; set; }
}
[Fact]
public void QueryMultimapFromClosed()
{
using var conn = GetClosedConnection();
Assert.Equal(ConnectionState.Closed, conn.State);
var i = conn.Query<Multi1, Multi2, int>("select 2 as [Id], 3 as [Id]", (x, y) => x.Id + y.Id).Single();
Assert.Equal(ConnectionState.Closed, conn.State);
Assert.Equal(5, i);
}
[Fact]
public void TestMultiMapThreeTypesWithGridReader()
{
const string createSql = @"
create table #Users (Id int, Name varchar(20))
create table #Posts (Id int, OwnerId int, Content varchar(20))
create table #Comments (Id int, PostId int, CommentData varchar(20))
insert #Users values(99, 'Sam')
insert #Users values(2, 'I am')
insert #Posts values(1, 99, 'Sams Post1')
insert #Posts values(2, 99, 'Sams Post2')
insert #Posts values(3, null, 'no ones post')
insert #Comments values(1, 1, 'Comment 1')";
connection.Execute(createSql);
try
{
const string sql = @"SELECT p.* FROM #Posts p
select p.*, u.Id, u.Name + '0' Name, c.Id, c.CommentData from #Posts p
left join #Users u on u.Id = p.OwnerId
left join #Comments c on c.PostId = p.Id
where p.Id = 1
Order by p.Id";
var grid = connection.QueryMultiple(sql);
var post1 = grid.Read<Post>().ToList();
var post2 = grid.Read<Post, User, Comment, Post>((post, user, comment) => { post.Owner = user; post.Comment = comment; return post; }).SingleOrDefault();
Assert.NotNull(post2);
Assert.NotNull(post2.Comment);
Assert.Equal(1, post2.Comment.Id);
Assert.NotNull(post2.Owner);
Assert.Equal(99, post2.Owner.Id);
}
finally
{
connection.Execute("drop table #Users drop table #Posts drop table #Comments");
}
}
[Fact]
public void TestMultiMapperIsNotConfusedWithUnorderedCols()
{
var result = connection.Query<Foo1, Bar1, Tuple<Foo1, Bar1>>("select 1 as Id, 2 as BarId, 3 as BarId, 'a' as Name", Tuple.Create, splitOn: "BarId").First();
Assert.Equal(1, result.Item1.Id);
Assert.Equal(2, result.Item1.BarId);
Assert.Equal(3, result.Item2.BarId);
Assert.Equal("a", result.Item2.Name);
}
[Fact]
public void TestMultiMapperSplitOnError()
{
var ex = Assert.Throws<ArgumentException>(() => connection.Query<Foo1, Bar1, Tuple<Foo1, Bar1>>("select 1 as Id, 2 as BarId", Tuple.Create, splitOn: "DoesntExist").First());
Assert.StartsWith("Multi-map error: splitOn column 'DoesntExist' was not found - please ensure your splitOn parameter is set and in the correct order", ex.Message);
}
[Fact]
public void TestMultiMapDynamic()
{
const string createSql = @"
create table #Users (Id int, Name varchar(20))
create table #Posts (Id int, OwnerId int, Content varchar(20))
insert #Users values(99, 'Sam')
insert #Users values(2, 'I am')
insert #Posts values(1, 99, 'Sams Post1')
insert #Posts values(2, 99, 'Sams Post2')
insert #Posts values(3, null, 'no ones post')
";
connection.Execute(createSql);
const string sql =
@"select * from #Posts p
left join #Users u on u.Id = p.OwnerId
Order by p.Id";
var data = connection.Query<dynamic, dynamic, dynamic>(sql, (post, user) => { post.Owner = user; return post; }).ToList();
var p = data[0];
// hairy extension method support for dynamics
Assert.Equal("Sams Post1", (string)p.Content);
Assert.Equal(1, (int)p.Id);
Assert.Equal("Sam", (string)p.Owner.Name);
Assert.Equal(99, (int)p.Owner.Id);
Assert.Null((object)data[2].Owner);
connection.Execute("drop table #Users drop table #Posts");
}
[Fact]
public void TestMultiMapWithSplit() // https://stackoverflow.com/q/6056778/23354
{
const string sql = "select 1 as id, 'abc' as name, 2 as id, 'def' as name";
var product = connection.Query<Product, Category, Product>(sql, (prod, cat) =>
{
prod.Category = cat;
return prod;
}).First();
// assertions
Assert.Equal(1, product.Id);
Assert.Equal("abc", product.Name);
Assert.NotNull(product.Category);
Assert.Equal(2, product.Category.Id);
Assert.Equal("def", product.Category.Name);
}
[Fact]
public void TestMultiMapWithSplitWithNullValue() // https://stackoverflow.com/q/10744728/449906
{
const string sql = "select 1 as id, 'abc' as name, NULL as description, 'def' as name";
var product = connection.Query<Product, Category, Product>(sql, (prod, cat) =>
{
prod.Category = cat;
return prod;
}, splitOn: "description").First();
// assertions
Assert.Equal(1, product.Id);
Assert.Equal("abc", product.Name);
Assert.Null(product.Category);
}
[Fact]
public void TestMultiMapWithSplitWithNullValueAndSpoofColumn() // https://stackoverflow.com/q/10744728/449906
{
const string sql = "select 1 as id, 'abc' as name, 1 as spoof, NULL as description, 'def' as name";
var product = connection.Query<Product, Category, Product>(sql, (prod, cat) =>
{
prod.Category = cat;
return prod;
}, splitOn: "spoof").First();
// assertions
Assert.Equal(1, product.Id);
Assert.Equal("abc", product.Name);
Assert.NotNull(product.Category);
Assert.Equal(0, product.Category.Id);
Assert.Equal("def", product.Category.Name);
Assert.Null(product.Category.Description);
}
[Fact]
public void TestMultiMappingVariations()
{
const string sql = "select 1 as Id, 'a' as Content, 2 as Id, 'b' as Content, 3 as Id, 'c' as Content, 4 as Id, 'd' as Content, 5 as Id, 'e' as Content";
var order = connection.Query<dynamic, dynamic, dynamic, dynamic>(sql, (o, owner, creator) => { o.Owner = owner; o.Creator = creator; return o; }).First();
Assert.Equal(order.Id, 1);
Assert.Equal(order.Content, "a");
Assert.Equal(order.Owner.Id, 2);
Assert.Equal(order.Owner.Content, "b");
Assert.Equal(order.Creator.Id, 3);
Assert.Equal(order.Creator.Content, "c");
order = connection.Query<dynamic, dynamic, dynamic, dynamic, dynamic>(sql, (o, owner, creator, address) =>
{
o.Owner = owner;
o.Creator = creator;
o.Owner.Address = address;
return o;
}).First();
Assert.Equal(order.Id, 1);
Assert.Equal(order.Content, "a");
Assert.Equal(order.Owner.Id, 2);
Assert.Equal(order.Owner.Content, "b");
Assert.Equal(order.Creator.Id, 3);
Assert.Equal(order.Creator.Content, "c");
Assert.Equal(order.Owner.Address.Id, 4);
Assert.Equal(order.Owner.Address.Content, "d");
order = connection.Query<dynamic, dynamic, dynamic, dynamic, dynamic, dynamic>(sql, (a, b, c, d, e) => { a.B = b; a.C = c; a.C.D = d; a.E = e; return a; }).First();
Assert.Equal(order.Id, 1);
Assert.Equal(order.Content, "a");
Assert.Equal(order.B.Id, 2);
Assert.Equal(order.B.Content, "b");
Assert.Equal(order.C.Id, 3);
Assert.Equal(order.C.Content, "c");
Assert.Equal(order.C.D.Id, 4);
Assert.Equal(order.C.D.Content, "d");
Assert.Equal(order.E.Id, 5);
Assert.Equal(order.E.Content, "e");
}
| Multi2 |
csharp | dotnet__maui | src/Essentials/src/Types/SensorSpeed.ios.tvos.watchos.cs | {
"start": 59,
"end": 461
} | partial class ____
{
internal static double ToPlatform(this SensorSpeed sensorSpeed)
{
switch (sensorSpeed)
{
case SensorSpeed.Fastest:
return sensorIntervalFastest / 1000.0;
case SensorSpeed.Game:
return sensorIntervalGame / 1000.0;
case SensorSpeed.UI:
return sensorIntervalUI / 1000.0;
}
return sensorIntervalDefault / 1000.0;
}
}
}
| SensorSpeedExtensions |
csharp | jellyfin__jellyfin | src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/ItemDisplayPreferences.cs | {
"start": 339,
"end": 3272
} | public class ____
{
/// <summary>
/// Initializes a new instance of the <see cref="ItemDisplayPreferences"/> class.
/// </summary>
/// <param name="userId">The user id.</param>
/// <param name="itemId">The item id.</param>
/// <param name="client">The client.</param>
public ItemDisplayPreferences(Guid userId, Guid itemId, string client)
{
UserId = userId;
ItemId = itemId;
Client = client;
SortBy = "SortName";
SortOrder = SortOrder.Ascending;
RememberSorting = false;
RememberIndexing = false;
}
/// <summary>
/// Gets the id.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int Id { get; private set; }
/// <summary>
/// Gets or sets the user Id.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
public Guid UserId { get; set; }
/// <summary>
/// Gets or sets the id of the associated item.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
public Guid ItemId { get; set; }
/// <summary>
/// Gets or sets the client string.
/// </summary>
/// <remarks>
/// Required. Max Length = 32.
/// </remarks>
[MaxLength(32)]
[StringLength(32)]
public string Client { get; set; }
/// <summary>
/// Gets or sets the view type.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
public ViewType ViewType { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the indexing should be remembered.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
public bool RememberIndexing { get; set; }
/// <summary>
/// Gets or sets what the view should be indexed by.
/// </summary>
public IndexingKind? IndexBy { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the sorting type should be remembered.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
public bool RememberSorting { get; set; }
/// <summary>
/// Gets or sets what the view should be sorted by.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
[MaxLength(64)]
[StringLength(64)]
public string SortBy { get; set; }
/// <summary>
/// Gets or sets the sort order.
/// </summary>
/// <remarks>
/// Required.
/// </remarks>
public SortOrder SortOrder { get; set; }
}
}
| ItemDisplayPreferences |
csharp | simplcommerce__SimplCommerce | src/Modules/SimplCommerce.Module.Core/Models/Role.cs | {
"start": 165,
"end": 319
} | public class ____ : IdentityRole<long>, IEntityWithTypedId<long>
{
public IList<UserRole> Users { get; set; } = new List<UserRole>();
}
}
| Role |
csharp | ServiceStack__ServiceStack | ServiceStack/src/ServiceStack.Common/Script/Blocks/HtmlScriptBlocks.cs | {
"start": 4488,
"end": 4626
} | public class ____ : ScriptHtmlBlock
{
public override string Tag => "script";
public override string Suffix => "";
}
| ScriptScriptBlock |
csharp | neuecc__MessagePack-CSharp | src/MessagePack/Resolvers/StandardResolver.cs | {
"start": 8098,
"end": 9118
} | private static class ____<T>
{
public static readonly IMessagePackFormatter<T>? Formatter;
static FormatterCache()
{
if (typeof(T) == typeof(object))
{
// final fallback
Formatter = DynamicAssembly.AvoidDynamicCode
? PrimitiveObjectResolver.Instance.GetFormatter<T>()
: (IMessagePackFormatter<T>)DynamicObjectTypeFallbackFormatter.Instance;
}
else
{
foreach (IFormatterResolver item in Resolvers)
{
IMessagePackFormatter<T>? f = item.GetFormatter<T>();
if (f != null)
{
Formatter = f;
return;
}
}
}
}
}
}
}
namespace MessagePack.Internal
{
| FormatterCache |
csharp | ChilliCream__graphql-platform | src/HotChocolate/AspNetCore/test/Transport.Http.Tests/GraphQLHttpClientConfigurationTests.cs | {
"start": 140,
"end": 913
} | public class ____
{
[Fact]
public async Task DefaultRequestVersion()
{
var httpClient = new HttpClient(new TestHttpMessageHandler(
request =>
{
Assert.Equal(HttpVersion.Version20, request.Version);
Assert.Equal(HttpVersionPolicy.RequestVersionOrHigher, request.VersionPolicy);
return new();
}
))
{
DefaultRequestVersion = HttpVersion.Version20,
DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher
};
var client = GraphQLHttpClient.Create(httpClient, true);
await client.SendAsync(new("{ __typename }", new(CreateUrl(null))), CancellationToken.None);
}
| GraphQLHttpClientConfigurationTests |
csharp | ServiceStack__ServiceStack | ServiceStack.Text/tests/ServiceStack.Text.Tests/AutoMappingTests.cs | {
"start": 33043,
"end": 34115
} | public class ____
{
public string Public { get; set; }
[IgnoreOnSelect]
public string Private { get; set; }
}
[Test]
public void Does_convert_same_model_without_Attributes()
{
var vm = new ViewModel().PopulateFromPropertiesWithoutAttribute(
new ViewModel { Public = "Public", Private = "Private" },
typeof(IgnoreOnSelectAttribute));
Assert.That(vm.Public, Is.EqualTo("Public"));
Assert.That(vm.Private, Is.Null);
}
[Test]
public void Can_use_ToObjectDictionary_to_Remove_Property_with_Attribute()
{
var vm = new ViewModel {Public = "Public", Private = "Private"};
var map = vm.ToObjectDictionary();
vm.GetType().GetProperties()
.Where(x => x.HasAttribute<IgnoreOnSelectAttribute>())
.Each(x => map.Remove(x.Name));
vm = map.FromObjectDictionary<ViewModel>();
Assert.That(vm.Public, Is.EqualTo("Public"));
Assert.That(vm.Private, Is.Null);
}
| ViewModel |
csharp | graphql-dotnet__graphql-dotnet | src/GraphQL.Tests/Bugs/Bug956.cs | {
"start": 950,
"end": 1066
} | public class ____ : Schema
{
public Bug956Schema()
{
Query = new Bug956QueryType();
}
}
| Bug956Schema |
csharp | microsoft__semantic-kernel | dotnet/src/SemanticKernel.Core/TemplateEngine/Blocks/TextBlock.cs | {
"start": 140,
"end": 800
} | internal sealed class ____ : Block, ITextRendering
{
internal override BlockTypes Type => BlockTypes.Text;
public TextBlock(string? text, ILoggerFactory? loggerFactory = null)
: base(text, loggerFactory)
{
}
public TextBlock(string text, int startIndex, int stopIndex, ILoggerFactory? loggerFactory)
: base(text.Substring(startIndex, stopIndex - startIndex), loggerFactory)
{
}
public override bool IsValid(out string errorMsg)
{
errorMsg = "";
return true;
}
/// <inheritdoc/>
public object? Render(KernelArguments? arguments)
{
return this.Content;
}
}
| TextBlock |
csharp | smartstore__Smartstore | src/Smartstore.Web/Areas/Admin/Models/Media/MediaSettingsModel.cs | {
"start": 6489,
"end": 8143
} | public class ____ :
IMapper<MediaSettings, MediaSettingsModel>,
IMapper<MediaSettingsModel, MediaSettings>
{
public Task MapAsync(MediaSettings from, MediaSettingsModel to, dynamic parameters = null)
{
MiniMapper.Map(from, to);
to.ImageTypes = MapMediaType(from.ImageTypes, MediaType.Image);
to.VideoTypes = MapMediaType(from.VideoTypes, MediaType.Video);
to.AudioTypes = MapMediaType(from.AudioTypes, MediaType.Audio);
to.DocumentTypes = MapMediaType(from.DocumentTypes, MediaType.Document);
to.TextTypes = MapMediaType(from.TextTypes, MediaType.Text);
to.BinTypes = MapMediaType(from.BinTypes, MediaType.Binary);
return Task.CompletedTask;
}
public Task MapAsync(MediaSettingsModel from, MediaSettings to, dynamic parameters = null)
{
MiniMapper.Map(from, to);
to.ImageTypes = MapMediaType(from.ImageTypes, MediaType.Image);
to.VideoTypes = MapMediaType(from.VideoTypes, MediaType.Video);
to.AudioTypes = MapMediaType(from.AudioTypes, MediaType.Audio);
to.DocumentTypes = MapMediaType(from.DocumentTypes, MediaType.Document);
to.TextTypes = MapMediaType(from.TextTypes, MediaType.Text);
to.BinTypes = MapMediaType(from.BinTypes, MediaType.Binary);
return Task.CompletedTask;
}
private static string MapMediaType(string types, MediaType mediaType)
{
return types.NullEmpty() ?? string.Join(' ', mediaType.DefaultExtensions);
}
}
}
| MediaSettingsMapper |
csharp | MonoGame__MonoGame | MonoGame.Framework/Platform/Android/Devices/Sensors/Compass.cs | {
"start": 6009,
"end": 9223
} | class ____ : Java.Lang.Object, ISensorEventListener
{
internal Compass compass;
float[] valuesAccelerometer;
float[] valuesMagenticField;
float[] matrixR;
float[] matrixI;
float[] matrixValues;
public SensorListener()
{
valuesAccelerometer = new float[3];
valuesMagenticField = new float[3];
matrixR = new float[9];
matrixI = new float[9];
matrixValues = new float[3];
}
public void OnAccuracyChanged(Sensor sensor, SensorStatus accuracy)
{
//do nothing
}
public void OnSensorChanged(SensorEvent e)
{
try
{
switch (e.Sensor.Type)
{
case SensorType.Accelerometer:
valuesAccelerometer[0] = e.Values[0];
valuesAccelerometer[1] = e.Values[1];
valuesAccelerometer[2] = e.Values[2];
break;
case SensorType.MagneticField:
valuesMagenticField[0] = e.Values[0];
valuesMagenticField[1] = e.Values[1];
valuesMagenticField[2] = e.Values[2];
break;
}
compass.IsDataValid = SensorManager.GetRotationMatrix(matrixR, matrixI, valuesAccelerometer, valuesMagenticField);
if (compass.IsDataValid)
{
SensorManager.GetOrientation(matrixR, matrixValues);
CompassReading reading = new CompassReading();
reading.MagneticHeading = matrixValues[0];
Vector3 magnetometer = new Vector3(valuesMagenticField[0], valuesMagenticField[1], valuesMagenticField[2]);
reading.MagnetometerReading = magnetometer;
// We need the magnetic declination from true north to calculate the true heading from the magnetic heading.
// On Android, this is available through Android.Hardware.GeomagneticField, but this requires your geo position.
reading.TrueHeading = reading.MagneticHeading;
reading.Timestamp = DateTime.UtcNow;
compass.CurrentValue = reading;
}
}
catch (NullReferenceException)
{
//Occassionally an NullReferenceException is thrown when accessing e.Values??
// mono : Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object
// mono : at Android.Runtime.JNIEnv.GetObjectField (IntPtr jobject, IntPtr jfieldID) [0x00000] in <filename unknown>:0
// mono : at Android.Hardware.SensorEvent.get_Values () [0x00000] in <filename unknown>:0
}
}
}
}
} | SensorListener |
csharp | dotnet__efcore | test/EFCore.Relational.Tests/Metadata/RelationalPropertyAttributeConventionTest.cs | {
"start": 7325,
"end": 7514
} | public class ____
{
public int Id { get; set; }
[Column("Post Name", Order = 1, TypeName = "DECIMAL"), Comment("Test column comment")]
public string Name;
}
}
| F |
csharp | dotnet__efcore | test/EFCore.Specification.Tests/ModelBuilding/GiantModel.cs | {
"start": 51363,
"end": 51580
} | public class ____
{
public int Id { get; set; }
public RelatedEntity237 ParentEntity { get; set; }
public IEnumerable<RelatedEntity239> ChildEntities { get; set; }
}
| RelatedEntity238 |
csharp | ServiceStack__ServiceStack | ServiceStack.Stripe/src/ServiceStack.Stripe/StripeGateway.cs | {
"start": 1352,
"end": 1612
} | public class ____ : IPost, IReturn<StripeCharge>
{
[IgnoreDataMember]
public string ChargeId { get; set; }
public int? Amount { get; set; }
public bool? RefundApplicationFee { get; set; }
}
[Route("/charges/{ChargeId}/capture")]
| RefundStripeCharge |
csharp | Antaris__RazorEngine | src/source/RazorEngine.Core/Compilation/RoslynCompilerServiceBase.cs | {
"start": 712,
"end": 827
} | public abstract class ____ : CompilerServiceBase
{
[SecuritySafeCritical]
| RoslynCompilerServiceBase |
csharp | CommunityToolkit__dotnet | src/CommunityToolkit.Mvvm/Messaging/IMessengerExtensions.cs | {
"start": 22665,
"end": 27280
} | class
____ TToken : IEquatable<TToken>
{
ArgumentNullException.ThrowIfNull(messenger);
ArgumentNullException.ThrowIfNull(recipient);
ArgumentNullException.For<TToken>.ThrowIfNull(token);
ArgumentNullException.ThrowIfNull(handler);
messenger.Register(recipient, token, handler);
}
/// <summary>
/// Unregisters a recipient from messages of a given type.
/// </summary>
/// <typeparam name="TMessage">The type of message to stop receiving.</typeparam>
/// <param name="messenger">The <see cref="IMessenger"/> instance to use to unregister the recipient.</param>
/// <param name="recipient">The recipient to unregister.</param>
/// <remarks>
/// This method will unregister the target recipient only from the default channel.
/// If the recipient has no registered handler, this method does nothing.
/// </remarks>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="messenger"/> or <paramref name="recipient"/> are <see langword="null"/>.</exception>
public static void Unregister<TMessage>(this IMessenger messenger, object recipient)
where TMessage : class
{
ArgumentNullException.ThrowIfNull(messenger);
ArgumentNullException.ThrowIfNull(recipient);
messenger.Unregister<TMessage, Unit>(recipient, default);
}
/// <summary>
/// Sends a message of the specified type to all registered recipients.
/// </summary>
/// <typeparam name="TMessage">The type of message to send.</typeparam>
/// <param name="messenger">The <see cref="IMessenger"/> instance to use to send the message.</param>
/// <returns>The message that has been sent.</returns>
/// <remarks>
/// This method is a shorthand for <see cref="Send{TMessage}(IMessenger,TMessage)"/> when the
/// message type exposes a parameterless constructor: it will automatically create
/// a new <typeparamref name="TMessage"/> instance and send that to its recipients.
/// </remarks>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="messenger"/> is <see langword="null"/>.</exception>
public static TMessage Send<TMessage>(this IMessenger messenger)
where TMessage : class, new()
{
ArgumentNullException.ThrowIfNull(messenger);
return messenger.Send(new TMessage(), default(Unit));
}
/// <summary>
/// Sends a message of the specified type to all registered recipients.
/// </summary>
/// <typeparam name="TMessage">The type of message to send.</typeparam>
/// <param name="messenger">The <see cref="IMessenger"/> instance to use to send the message.</param>
/// <param name="message">The message to send.</param>
/// <returns>The message that was sent (ie. <paramref name="message"/>).</returns>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="messenger"/> or <paramref name="message"/> are <see langword="null"/>.</exception>
public static TMessage Send<TMessage>(this IMessenger messenger, TMessage message)
where TMessage : class
{
ArgumentNullException.ThrowIfNull(messenger);
ArgumentNullException.ThrowIfNull(message);
return messenger.Send(message, default(Unit));
}
/// <summary>
/// Sends a message of the specified type to all registered recipients.
/// </summary>
/// <typeparam name="TMessage">The type of message to send.</typeparam>
/// <typeparam name="TToken">The type of token to identify what channel to use to send the message.</typeparam>
/// <param name="messenger">The <see cref="IMessenger"/> instance to use to send the message.</param>
/// <param name="token">The token indicating what channel to use.</param>
/// <returns>The message that has been sent.</returns>
/// <remarks>
/// This method will automatically create a new <typeparamref name="TMessage"/> instance
/// just like <see cref="Send{TMessage}(IMessenger)"/>, and then send it to the right recipients.
/// </remarks>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="messenger"/> or <paramref name="token"/> are <see langword="null"/>.</exception>
public static TMessage Send<TMessage, TToken>(this IMessenger messenger, TToken token)
where TMessage : class, new()
where TToken : IEquatable<TToken>
{
ArgumentNullException.ThrowIfNull(messenger);
ArgumentNullException.For<TToken>.ThrowIfNull(token);
return messenger.Send(new TMessage(), token);
}
}
| where |
csharp | smartstore__Smartstore | src/Smartstore/Imaging/Barcodes/BarcodePayload.cs | {
"start": 118,
"end": 1501
} | public class ____ : IEquatable<BarcodePayload>
{
public BarcodePayload(string data, BarcodeType type)
{
Guard.NotEmpty(data, nameof(data));
Data = data;
Type = type;
}
/// <summary>
/// The string data to encode.
/// </summary>
public virtual string Data { get; }
/// <summary>
/// The barcode type to generate.
/// </summary>
public BarcodeType Type { get; }
/// <summary>
/// Whether the current barcode type is any EAN type.
/// </summary>
public bool IsEan
{
get => Type is (BarcodeType.Ean or BarcodeType.UPCA or BarcodeType.UPCE);
}
public override string ToString()
=> Data;
public bool Equals(BarcodePayload other)
{
if (other == null)
{
return false;
}
if (ReferenceEquals(this, other))
{
return true;
}
return GetType() == other.GetType() &&
Type == other.Type &&
Data == other.Data;
}
public override bool Equals(object obj)
=> Equals(obj as QrPayload);
public override int GetHashCode()
=> Data.GetHashCode();
}
}
| BarcodePayload |
csharp | GtkSharp__GtkSharp | Source/Libs/GtkSharp/Bin.cs | {
"start": 23,
"end": 887
} | class ____
//
// Author: Mike Kestner <mkestner@ximian.com>
//
// Copyright (C) 2004 Novell, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the Lesser GNU General
// Public License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
namespace Gtk {
using System;
using System.Runtime.InteropServices;
| customizations |
csharp | nopSolutions__nopCommerce | src/Tests/Nop.Tests/Nop.Services.Tests/Orders/OrderServiceTests.cs | {
"start": 184,
"end": 2981
} | public class ____ : ServiceTest
{
private IOrderService _orderService;
[OneTimeSetUp]
public void SetUp()
{
_orderService = GetService<IOrderService>();
}
[Test]
public async Task ItShouldReturnNullOrderWhenOrderIdIsZero()
{
var order = await _orderService.GetOrderByIdAsync(0);
order.Should().BeNull();
}
[Test]
public async Task ItShouldReturnEmptyOrdersWhenOrderIdsNull()
{
var orders = await _orderService.GetOrdersByIdsAsync(null);
orders.Count.Should().Be(0);
}
[Test]
public async Task ItShouldReturnEmptyOrdersWhenOrderIdsEmpty()
{
var orders = await _orderService.GetOrdersByIdsAsync(Array.Empty<int>());
orders.Count.Should().Be(0);
}
[Test]
public async Task ItShouldReturnOrdersByIds()
{
var orders = await _orderService.GetOrdersByIdsAsync([1, 2]);
orders.Count.Should().Be(2);
}
[Test]
public async Task ItShouldReturnNullWhenGuidIsEmpty()
{
var order = await _orderService.GetOrderByGuidAsync(Guid.Empty);
order.Should().BeNull();
}
[Test]
public async Task ItShouldGetOrderByGuidWhenGuidNotEmpty()
{
var order = await _orderService.GetOrderByIdAsync(1);
var foundedOrder = await _orderService.GetOrderByGuidAsync(order.OrderGuid);
foundedOrder.Id.Should().Be(order.Id);
}
[Test]
public void ItShouldThrowExceptionIfOrderIsNullWhenDeleteOrder()
{
Assert.Throws(typeof(AggregateException), () => _orderService.DeleteOrderAsync(null).Wait());
}
[Test]
public async Task ItShouldDeleteOrder()
{
var order = await _orderService.GetOrderByIdAsync(1);
await _orderService.DeleteOrderAsync(order);
order.Deleted.Should().BeTrue();
order = await GetService<IRepository<Order>>().GetByIdAsync(1);
order.Should().NotBeNull();
order.Deleted = false;
await _orderService.UpdateOrderAsync(order);
}
[Test]
public void ItShouldThrowIfOrderIsNullWhenInsertOrder()
{
Assert.Throws<AggregateException>(() => _orderService.InsertOrderAsync(null).Wait());
}
[Test]
public async Task ItShouldInsertOrder()
{
var order = new Order
{
CustomOrderNumber = string.Empty,
CustomerId = 1,
BillingAddressId = 1
};
await _orderService.InsertOrderAsync(order);
order.Id.Should().BeGreaterThan(0);
await GetService<IRepository<Order>>().DeleteAsync(order);
}
[Test]
public void ItShouldThrowIfOrderIsNullWhenUpdateOrder()
{
Assert.Throws<AggregateException>(() => _orderService.UpdateOrderAsync(null).Wait());
}
} | OrderServiceTests |
csharp | ServiceStack__ServiceStack | ServiceStack/tests/ServiceStack.WebHost.Endpoints.Tests/Support/Host/ExampleAppHostHttpListener.cs | {
"start": 707,
"end": 799
} | public class ____
{
[DataMember]
public long Result { get; set; }
}
| GetFactorialResponse |
csharp | unoplatform__uno | src/Uno.UWP/Generated/3.0.0.0/Windows.Media.Capture/PhotoCaptureSource.cs | {
"start": 259,
"end": 683
} | public enum ____
{
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
Auto = 0,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
VideoPreview = 1,
#endif
#if __ANDROID__ || __IOS__ || __TVOS__ || IS_UNIT_TESTS || __WASM__ || __SKIA__ || __NETSTD_REFERENCE__
Photo = 2,
#endif
}
#endif
}
| PhotoCaptureSource |
csharp | abpframework__abp | framework/src/Volo.Abp.BlobStoring.Bunny/Volo/Abp/BlobStoring/Bunny/IBunnyClientFactory.cs | {
"start": 99,
"end": 375
} | public interface ____
{
Task<BunnyCDNStorage> CreateAsync(string accessKey, string containerName, string region = "de");
Task EnsureStorageZoneExistsAsync(string accessKey, string containerName, string region = "de", bool createIfNotExists = false);
}
| IBunnyClientFactory |
csharp | AvaloniaUI__Avalonia | src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs | {
"start": 80423,
"end": 80660
} | internal struct ____
{
public int dwStyle;
public POINT ptCurrentPos;
public RECT rcArea;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
| COMPOSITIONFORM |
csharp | dotnet__efcore | src/ef/AnsiTextWriter.cs | {
"start": 251,
"end": 3027
} | internal class ____(TextWriter writer)
{
public void WriteLine(string? text)
{
if (text != null)
{
Interpret(text);
}
writer.Write(Environment.NewLine);
}
private void Interpret(string value)
{
var matches = Regex.Matches(value, "\x1b\\[([0-9]+)?m", RegexOptions.None, TimeSpan.FromSeconds(10));
var start = 0;
foreach (var match in matches.Cast<Match>())
{
var length = match.Index - start;
if (length != 0)
{
writer.Write(value.Substring(start, length));
}
Apply(match.Groups[1].Value);
start = match.Index + match.Length;
}
if (start != value.Length)
{
writer.Write(value.Substring(start));
}
}
private static void Apply(string parameter)
{
switch (parameter)
{
case "1":
ApplyBold();
break;
case "22":
ResetBold();
break;
case "30":
ApplyColor(ConsoleColor.Black);
break;
case "31":
ApplyColor(ConsoleColor.DarkRed);
break;
case "32":
ApplyColor(ConsoleColor.DarkGreen);
break;
case "33":
ApplyColor(ConsoleColor.DarkYellow);
break;
case "34":
ApplyColor(ConsoleColor.DarkBlue);
break;
case "35":
ApplyColor(ConsoleColor.DarkMagenta);
break;
case "36":
ApplyColor(ConsoleColor.DarkCyan);
break;
case "37":
ApplyColor(ConsoleColor.Gray);
break;
case "39":
ResetColor();
break;
default:
Debug.Fail("Unsupported parameter: " + parameter);
break;
}
}
private static void ApplyBold()
=> Console.ForegroundColor = (ConsoleColor)((int)Console.ForegroundColor | 8);
private static void ResetBold()
=> Console.ForegroundColor = (ConsoleColor)((int)Console.ForegroundColor & 7);
private static void ApplyColor(ConsoleColor color)
{
var wasBold = ((int)Console.ForegroundColor & 8) != 0;
Console.ForegroundColor = color;
if (wasBold)
{
ApplyBold();
}
}
private static void ResetColor()
{
var wasBold = ((int)Console.ForegroundColor & 8) != 0;
Console.ResetColor();
if (wasBold)
{
ApplyBold();
}
}
}
| AnsiTextWriter |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.