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 | DuendeSoftware__IdentityServer | identity-server/test/IdentityServer.UnitTests/Endpoints/Token/StubTokenResponseGenerator.cs | {
"start": 247,
"end": 512
} | internal class ____ : ITokenResponseGenerator
{
public TokenResponse Response { get; set; } = new TokenResponse();
public Task<TokenResponse> ProcessAsync(TokenRequestValidationResult validationResult) => Task.FromResult(Response);
}
| StubTokenResponseGenerator |
csharp | ChilliCream__graphql-platform | src/HotChocolate/AspNetCore/src/AspNetCore.Pipeline/Formatters/DefaultHttpResponseFormatter.cs | {
"start": 27818,
"end": 29080
} | private sealed class ____
{
private readonly byte[] _schema;
public CachedSchemaOutput(ISchemaDefinition schema, ulong version, DateTimeOffset lastModifiedTime)
{
_schema = Encoding.UTF8.GetBytes(schema.ToString());
FileName = GetSchemaFileName(schema);
ETag = CreateETag(_schema, version);
LastModifiedTime = lastModifiedTime;
Version = version;
}
public string FileName { get; }
public string ETag { get; }
public ulong Version { get; }
public DateTimeOffset LastModifiedTime { get; }
public ReadOnlyMemory<byte> AsMemory() => _schema;
private static string CreateETag(byte[] schema, ulong version)
{
using var sha256 = SHA256.Create();
var hashBytes = sha256.ComputeHash(schema);
var hash = Convert.ToBase64String(hashBytes);
return $"\"{version}-{hash}\"";
}
private static string GetSchemaFileName(ISchemaDefinition schema)
=> schema.Name.Equals(ISchemaDefinition.DefaultName, StringComparison.OrdinalIgnoreCase)
? "schema.graphql"
: schema.Name + ".schema.graphql";
}
}
| CachedSchemaOutput |
csharp | abpframework__abp | modules/docs/src/Volo.Docs.MongoDB/Volo/Docs/Documents/MongoDocumentRepository.cs | {
"start": 334,
"end": 13997
} | public class ____ : MongoDbRepository<IDocsMongoDbContext, Document, Guid>, IDocumentRepository
{
public MongoDocumentRepository(IMongoDbContextProvider<IDocsMongoDbContext> dbContextProvider)
: base(dbContextProvider)
{
}
public virtual async Task<List<DocumentWithoutDetails>> GetListWithoutDetailsByProjectId(Guid projectId, CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken))
.Where(d => d.ProjectId == projectId)
.Select(x => new DocumentWithoutDetails
{
Id = x.Id,
Version = x.Version,
LanguageCode = x.LanguageCode,
Format = x.Format,
Name = x.Name
})
.ToListAsync(GetCancellationToken(cancellationToken));
}
public virtual async Task<List<DocumentInfo>> GetUniqueListDocumentInfoAsync(CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken))
.Select(x=> new DocumentInfo {
ProjectId = x.ProjectId,
Version = x.Version,
LanguageCode = x.LanguageCode,
Format = x.Format
})
.Distinct()
.OrderByDescending(x=>x.Version)
.ToListAsync(GetCancellationToken(cancellationToken));
}
public virtual async Task<List<Document>> GetListByProjectId(Guid projectId, CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken)).Where(d => d.ProjectId == projectId).ToListAsync(GetCancellationToken(cancellationToken));
}
public virtual async Task<List<Document>> GetUniqueDocumentsByProjectIdPagedAsync(Guid projectId, int skipCount, int maxResultCount,
CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken))
.Where(d => d.ProjectId == projectId)
.OrderBy(x => x.LastCachedTime)
.GroupBy(x => new { x.Name, x.LanguageCode, x.Version })
.Select(group => group.First())
.Skip(skipCount)
.Take(maxResultCount)
.ToListAsync(cancellationToken);
}
public virtual async Task<long> GetUniqueDocumentCountByProjectIdAsync(Guid projectId, CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken)).Where(d => d.ProjectId == projectId)
.GroupBy(x => new { x.Name, x.LanguageCode, x.Version })
.LongCountAsync(GetCancellationToken(cancellationToken));
}
public async Task UpdateProjectLastCachedTimeAsync(Guid projectId, DateTime cachedTime,
CancellationToken cancellationToken = default)
{
var collection = await GetCollectionAsync(cancellationToken);
await collection.UpdateManyAsync(
Builders<Document>.Filter.Eq(x => x.ProjectId, projectId),
Builders<Document>.Update.Set(x => x.LastCachedTime, cachedTime),
cancellationToken: GetCancellationToken(cancellationToken)
);
}
public virtual async Task<Document> FindAsync(Guid projectId, string name, string languageCode, string version,
bool includeDetails = true,
CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken)).FirstOrDefaultAsync(x =>
x.ProjectId == projectId &&
x.Name == name &&
x.LanguageCode == languageCode &&
x.Version == version, GetCancellationToken(cancellationToken));
}
public virtual async Task<Document> FindAsync(Guid projectId, List<string> possibleNames, string languageCode, string version,
bool includeDetails = true,
CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken)).FirstOrDefaultAsync(x => x.ProjectId == projectId &&
possibleNames.Contains(x.Name) &&
x.LanguageCode == languageCode &&
x.Version == version, GetCancellationToken(cancellationToken));
}
public virtual async Task DeleteAsync(Guid projectId, string name, string languageCode, string version, bool autoSave = false, CancellationToken cancellationToken = default)
{
await DeleteAsync(x =>
x.ProjectId == projectId && x.Name == name && x.LanguageCode == languageCode &&
x.Version == version, autoSave, cancellationToken: cancellationToken);
}
public virtual async Task<List<Document>> GetListAsync(Guid? projectId, string version, string name, CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken))
.WhereIf(version != null, x => x.Version == version)
.WhereIf(name != null, x => x.Name == name)
.WhereIf(projectId.HasValue, x => x.ProjectId == projectId)
.ToListAsync(GetCancellationToken(cancellationToken));
}
public virtual async Task<List<DocumentWithoutContent>> GetAllAsync(
Guid? projectId,
string name,
string version,
string languageCode,
string fileName,
string format,
DateTime? creationTimeMin,
DateTime? creationTimeMax,
DateTime? lastUpdatedTimeMin,
DateTime? lastUpdatedTimeMax,
DateTime? lastSignificantUpdateTimeMin,
DateTime? lastSignificantUpdateTimeMax,
DateTime? lastCachedTimeMin,
DateTime? lastCachedTimeMax,
string sorting = null,
int maxResultCount = int.MaxValue,
int skipCount = 0,
CancellationToken cancellationToken = default)
{
return await
(await ApplyFilterForGetAll(
await GetQueryableAsync(cancellationToken),
projectId: projectId,
name: name,
version: version,
languageCode: languageCode,
fileName: fileName,
format: format,
creationTimeMin: creationTimeMin,
creationTimeMax: creationTimeMax,
lastUpdatedTimeMin: lastUpdatedTimeMin,
lastUpdatedTimeMax: lastUpdatedTimeMax,
lastSignificantUpdateTimeMin: lastSignificantUpdateTimeMin,
lastSignificantUpdateTimeMax: lastSignificantUpdateTimeMax,
lastCachedTimeMin: lastCachedTimeMin, lastCachedTimeMax: lastCachedTimeMax, cancellationToken: cancellationToken))
.OrderBy(string.IsNullOrWhiteSpace(sorting) ? "name asc" : sorting)
.PageBy(skipCount, maxResultCount)
.ToListAsync(GetCancellationToken(cancellationToken));
}
public virtual async Task<long> GetAllCountAsync(
Guid? projectId,
string name,
string version,
string languageCode,
string fileName,
string format,
DateTime? creationTimeMin,
DateTime? creationTimeMax,
DateTime? lastUpdatedTimeMin,
DateTime? lastUpdatedTimeMax,
DateTime? lastSignificantUpdateTimeMin,
DateTime? lastSignificantUpdateTimeMax,
DateTime? lastCachedTimeMin,
DateTime? lastCachedTimeMax,
string sorting = null,
int maxResultCount = int.MaxValue,
int skipCount = 0,
CancellationToken cancellationToken = default)
{
return await
(await ApplyFilterForGetAll(
await GetQueryableAsync(cancellationToken),
projectId: projectId,
name: name,
version: version,
languageCode: languageCode,
fileName: fileName,
format: format,
creationTimeMin: creationTimeMin,
creationTimeMax: creationTimeMax,
lastUpdatedTimeMin: lastUpdatedTimeMin,
lastUpdatedTimeMax: lastUpdatedTimeMax,
lastSignificantUpdateTimeMin: lastSignificantUpdateTimeMin,
lastSignificantUpdateTimeMax: lastSignificantUpdateTimeMax,
lastCachedTimeMin: lastCachedTimeMin, lastCachedTimeMax: lastCachedTimeMax,
cancellationToken: cancellationToken))
.OrderBy(string.IsNullOrWhiteSpace(sorting) ? "name asc" : sorting)
.PageBy(skipCount, maxResultCount)
.LongCountAsync(GetCancellationToken(cancellationToken));
}
public virtual async Task<Document> GetAsync(Guid id, CancellationToken cancellationToken = default)
{
return await (await GetQueryableAsync(cancellationToken)).Where(x => x.Id == id).SingleAsync(GetCancellationToken(cancellationToken));
}
protected virtual async Task<IQueryable<DocumentWithoutContent>> ApplyFilterForGetAll(
IQueryable<Document> query,
Guid? projectId,
string name,
string version,
string languageCode,
string fileName,
string format,
DateTime? creationTimeMin,
DateTime? creationTimeMax,
DateTime? lastUpdatedTimeMin,
DateTime? lastUpdatedTimeMax,
DateTime? lastSignificantUpdateTimeMin,
DateTime? lastSignificantUpdateTimeMax,
DateTime? lastCachedTimeMin,
DateTime? lastCachedTimeMax,
CancellationToken cancellationToken = default)
{
if (projectId.HasValue)
{
query = query.Where(d => d.ProjectId == projectId.Value);
}
if (name != null)
{
query = query.Where(d => d.Name != null && d.Name.Contains(name));
}
if (version != null)
{
query = query.Where(d => d.Version != null && d.Version == version);
}
if (languageCode != null)
{
query = query.Where(d => d.LanguageCode != null && d.LanguageCode == languageCode);
}
if (fileName != null)
{
query = query.Where(d => d.FileName != null && d.FileName.Contains(fileName));
}
if (format != null)
{
query = query.Where(d => d.Format != null && d.Format == format);
}
if (creationTimeMin.HasValue)
{
query = query.Where(d => d.CreationTime.Date >= creationTimeMin.Value.Date);
}
if (creationTimeMax.HasValue)
{
query = query.Where(d => d.CreationTime.Date <= creationTimeMax.Value.Date);
}
if (lastUpdatedTimeMin.HasValue)
{
query = query.Where(d => d.LastUpdatedTime.Date >= lastUpdatedTimeMin.Value.Date);
}
if (lastUpdatedTimeMax.HasValue)
{
query = query.Where(d => d.LastUpdatedTime.Date <= lastUpdatedTimeMax.Value.Date);
}
if (lastSignificantUpdateTimeMin.HasValue)
{
query = query.Where(d => d.LastSignificantUpdateTime != null && d.LastSignificantUpdateTime.Value.Date >= lastSignificantUpdateTimeMin.Value.Date);
}
if (lastSignificantUpdateTimeMax.HasValue)
{
query = query.Where(d => d.LastSignificantUpdateTime != null && d.LastSignificantUpdateTime.Value.Date <= lastSignificantUpdateTimeMax.Value.Date);
}
if (lastCachedTimeMin.HasValue)
{
query = query.Where(d => d.LastCachedTime.Date >= lastCachedTimeMin.Value.Date);
}
if (lastCachedTimeMax.HasValue)
{
query = query.Where(d => d.LastCachedTime.Date <= lastCachedTimeMax.Value.Date);
}
var join = query.Join(
(await GetDbContextAsync(cancellationToken)).Projects,
d => d.ProjectId,
p => p.Id,
(d, p) => new { Document = d, Project = p });
return join.Select(x => new DocumentWithoutContent
{
Id = x.Document.Id,
ProjectId = x.Document.ProjectId,
ProjectName = x.Project.Name,
Name = x.Document.Name,
Version = x.Document.Version,
LanguageCode = x.Document.LanguageCode,
FileName = x.Document.FileName,
Format = x.Document.Format,
CreationTime = x.Document.CreationTime,
LastUpdatedTime = x.Document.LastUpdatedTime,
LastSignificantUpdateTime = x.Document.LastSignificantUpdateTime,
LastCachedTime = x.Document.LastCachedTime
});
}
}
}
| MongoDocumentRepository |
csharp | dotnet__machinelearning | src/Microsoft.ML.Transforms/SvmLight/SvmLightLoader.cs | {
"start": 20657,
"end": 36836
} | private sealed class ____ : RootCursorBase
{
private readonly TextDataView _parent;
private readonly bool _isActive;
private int _fileIdx;
private TextReader _currReader;
private ReadOnlyMemory<char> _text;
private readonly ValueGetter<ReadOnlyMemory<char>> _getter;
public override long Batch => 0;
public override DataViewSchema Schema => _parent.Schema;
public Cursor(TextDataView parent, bool isActive)
: base(parent._host)
{
_parent = parent;
_isActive = isActive;
if (_parent._files.Count == 0)
{
// Rather than corrupt MoveNextCore with a bunch of custom logic for
// the empty file case and make that less efficient, be slightly inefficient
// for our zero-row case.
_fileIdx = -1;
_currReader = new StringReader("");
_currReader.ReadLine();
// Beyond this point _currReader will return null from ReadLine.
}
else
_currReader = _parent._files.OpenTextReader(_fileIdx);
if (_isActive)
_getter = Getter;
}
private void Getter(ref ReadOnlyMemory<char> val)
{
Ch.Check(IsGood, "cannot call getter with cursor in its current state");
Ch.Assert(_isActive);
val = _text;
}
public override ValueGetter<TValue> GetGetter<TValue>(DataViewSchema.Column column)
{
Ch.CheckParam(column.Index == 0, nameof(column));
Ch.CheckParam(_isActive, nameof(column), "requested column not active");
ValueGetter<TValue> getter = _getter as ValueGetter<TValue>;
if (getter == null)
throw Ch.Except($"Invalid TValue: '{typeof(TValue)}', " +
$"expected type: '{_getter.GetType().GetGenericArguments().First()}'.");
return getter;
}
public override ValueGetter<DataViewRowId> GetIdGetter()
{
return
(ref DataViewRowId val) =>
{
Ch.Check(IsGood, "Cannot call ID getter in current state");
val = new DataViewRowId((ulong)Position, 0);
};
}
public override bool IsColumnActive(DataViewSchema.Column column)
{
Ch.CheckParam(column.Index == 0, nameof(column));
return _isActive;
}
protected override bool MoveNextCore()
{
Ch.AssertValue(_currReader);
Ch.Assert(-1 <= _fileIdx && _fileIdx < _parent._files.Count);
var count = _parent._files.Count;
for (; ; )
{
var line = _currReader.ReadLine();
if (line != null)
{
if (_isActive)
_text = line.AsMemory();
return true;
}
if (++_fileIdx == count)
return false;
Ch.AssertValue(_parent._files);
_currReader = _parent._files.OpenTextReader(_fileIdx);
}
}
}
}
private readonly IHost _host;
private readonly ITransformer _keyVectorsToIndexVectors;
private readonly FeatureIndices _indicesKind;
private readonly ulong _featureCount;
private readonly DataViewSchema _outputSchema;
internal const string Summary = "Loads text in the SVM-light format and close variants.";
internal const string UserName = "SVM-Light Loader";
internal const string LoaderSignature = "SvmLightLoader";
private static VersionInfo GetVersionInfo()
{
return new VersionInfo(
modelSignature: "SVMLTLDR",
verWrittenCur: 0x00010001, // Initial
verReadableCur: 0x00010001,
verWeCanReadBack: 0x00010001,
loaderSignature: LoaderSignature,
loaderAssemblyName: typeof(SvmLightLoader).Assembly.FullName);
}
internal SvmLightLoader(IHostEnvironment env, Options options = null, IMultiStreamSource dataSample = null)
{
Contracts.CheckValue(env, nameof(env));
_host = env.Register(LoaderSignature);
if (options == null)
options = new Options();
_host.CheckUserArg(options.InputSize >= 0, nameof(options.InputSize), "Maximum feature index must be positive, or 0 to infer it from the dataset");
_indicesKind = options.FeatureIndices;
if (_indicesKind != FeatureIndices.Names)
{
if (options.InputSize > 0)
_featureCount = (ulong)options.InputSize;
else
{
if (dataSample == null || dataSample.Count == 0)
throw env.Except("If the number of features is not specified, a dataset must be provided to infer it.");
var data = GetData(_host, options.NumberOfRows, dataSample);
_featureCount = InferMax(_host, data) + (ulong)(_indicesKind == FeatureIndices.ZeroBased ? 1 : 0);
}
_host.Assert(_featureCount <= int.MaxValue);
}
else
{
// We need to train a ValueToKeyMappingTransformer.
if (dataSample == null || dataSample.Count == 0)
throw env.Except("To use the text feature names option, a dataset must be provided");
var data = GetData(_host, options.NumberOfRows, dataSample);
_keyVectorsToIndexVectors = new ValueToKeyMappingEstimator(_host, nameof(IntermediateInput.FeatureKeys)).Fit(data);
var keyCol = _keyVectorsToIndexVectors.GetOutputSchema(data.Schema).GetColumnOrNull(nameof(Indices.FeatureKeys));
_host.Assert(keyCol.HasValue);
var keyType = keyCol.Value.Type.GetItemType() as KeyDataViewType;
_host.AssertValue(keyType);
_featureCount = keyType.Count;
}
_outputSchema = CreateOutputSchema();
}
private SvmLightLoader(IHost host, ModelLoadContext ctx)
{
Contracts.AssertValue(host, "host");
host.AssertValue(ctx);
_host = host;
// *** Binary format ***
// int: Whether the indices column type is a key type, integer starting with 0 or integet starting with 1.
// ulong: The number of features.
// submodel: The transformer converting the indices from text to numeric/key.
_indicesKind = (FeatureIndices)ctx.Reader.ReadInt32();
_featureCount = ctx.Reader.ReadUInt64();
ctx.LoadModelOrNull<ITransformer, SignatureLoadModel>(_host, out _keyVectorsToIndexVectors, "KeysToIndices");
}
internal static SvmLightLoader Create(IHostEnvironment env, ModelLoadContext ctx)
{
Contracts.CheckValue(env, nameof(env));
IHost h = env.Register(LoaderSignature);
h.CheckValue(ctx, nameof(ctx));
ctx.CheckAtModel(GetVersionInfo());
return h.Apply("Loading Model", ch => new SvmLightLoader(h, ctx));
}
void ICanSaveModel.Save(ModelSaveContext ctx)
{
_host.CheckValue(ctx, nameof(ctx));
ctx.CheckAtModel();
ctx.SetVersionInfo(GetVersionInfo());
// *** Binary format ***
// int: Whether the indices column type is a key type, integer starting with 0 or integet starting with 1.
// ulong: The number of features.
// submodel: The transformer converting the indices from text to numeric/key.
ctx.Writer.Write((int)_indicesKind);
ctx.Writer.Write(_featureCount);
if (_keyVectorsToIndexVectors != null)
ctx.SaveModel(_keyVectorsToIndexVectors, "KeysToIndices");
}
private DataViewSchema CreateOutputSchema()
{
var data = GetData(_host, null, new MultiFileSource(null));
var indexParser = new IndexParser(_indicesKind == FeatureIndices.ZeroBased, _featureCount);
var schemaDef = SchemaDefinition.Create(typeof(Indices));
schemaDef[nameof(Indices.FeatureKeys)].ColumnType = new KeyDataViewType(typeof(uint), _featureCount);
var keyVectorsToIndexVectors = _keyVectorsToIndexVectors ??
new CustomMappingTransformer<IntermediateInput, Indices>(_host, indexParser.ParseIndices, null);
var schema = keyVectorsToIndexVectors.GetOutputSchema(data.Schema);
return CreateOutputTransformer(_host, (int)_featureCount,
_indicesKind == FeatureIndices.Names, schema).GetOutputSchema(schema);
}
private static IDataView GetData(IHostEnvironment env, long? numRows, IMultiStreamSource dataSample)
{
IDataView data = new TextDataView(env, dataSample);
// First stage of the transform, effectively comment out comment lines. Comment lines are those
// whose very first character is a '#'. We add an NAFilter to filter out entire lines that start with '#'.
// REVIEW: When ML.NET supports custom mappings for filters, we can replace this stage with a custom filter.
var transformer = new CustomMappingTransformer<Input, CommentIndicator>(env, Input.MapComment, null);
data = transformer.Transform(data);
data = new NAFilter(env, data, columns: nameof(CommentIndicator.IsComment));
// Second stage of the transform, parse out the features into a text vector of keys/indices and a text vector of values.
// If we are loading the data for training a KeyToValueTransformer, users can specify the number of rows to train on.
var inputMapper = new InputMapper();
data = new CustomMappingTransformer<Input, IntermediateInput>(env, inputMapper.MapInput, null).Transform(data);
if (numRows.HasValue)
data = SkipTakeFilter.Create(env, new SkipTakeFilter.TakeOptions() { Count = numRows.Value }, data);
return data;
}
private static uint InferMax(IHostEnvironment env, IDataView view)
{
ulong keyMax = 0;
var parser = Conversions.DefaultInstance.GetTryParseConversion<ulong>(NumberDataViewType.UInt64);
var col = view.Schema.GetColumnOrNull(nameof(IntermediateInput.FeatureKeys));
env.Assert(col.HasValue);
using (var ch = env.Start("Infer key transform"))
using (var cursor = view.GetRowCursor(col.Value))
{
VBuffer<ReadOnlyMemory<char>> result = default;
var getter = cursor.GetGetter<VBuffer<ReadOnlyMemory<char>>>(col.Value);
long count = 0;
long missingCount = 0;
while (cursor.MoveNext())
{
getter(ref result);
var values = result.GetValues();
for (int i = 0; i < values.Length; ++i)
{
if (!parser(in values[i], out var val) || val > int.MaxValue)
{
missingCount++;
continue;
}
count++;
if (keyMax < val)
keyMax = val;
}
}
if (missingCount > 0)
ch.Warning($"{missingCount} of {count + missingCount} detected keys were missing, unparsable or greater than {int.MaxValue}");
if (count == 0)
throw ch.Except("No int parsable keys found during key transform inference");
ch.Info("Observed max was {0}", keyMax);
}
return (uint)keyMax;
}
private static ITransformer CreateOutputTransformer(IHostEnvironment env, int keyCount, bool keyIndices, DataViewSchema inputSchema)
{
// Third stage of the transform, do what amounts to a weighted KeyToVector transform.
// REVIEW: Really the KeyToVector transform should have support for weights on the keys.
// If we add this, replace this stuff with that.
var outputMapper = new OutputMapper(keyCount);
// The size of the output is fixed, so just update the schema definition to reflect that.
var schemaDef = SchemaDefinition.Create(typeof(Output));
env.Assert(schemaDef.Count == 1);
schemaDef[0].ColumnType = new VectorDataViewType(NumberDataViewType.Single, keyCount);
ITransformer outputTransformer;
if (keyIndices)
{
var col = inputSchema[nameof(Indices.FeatureKeys)];
var keyValuesCol = col.Annotations.Schema.GetColumnOrNull(AnnotationUtils.Kinds.KeyValues);
if (keyValuesCol.HasValue)
{
VBuffer<ReadOnlyMemory<char>> keyValues = default;
col.Annotations.GetValue(AnnotationUtils.Kinds.KeyValues, ref keyValues);
schemaDef[0].AddAnnotation(AnnotationUtils.Kinds.SlotNames, keyValues, keyValuesCol.Value.Type);
}
outputTransformer = new CustomMappingTransformer<IntermediateOut, Output>(env,
outputMapper.Map, null, outputSchemaDefinition: schemaDef);
}
else
{
outputTransformer = new CustomMappingTransformer<IntermediateOut, Output>(env,
outputMapper.Map, null, outputSchemaDefinition: schemaDef);
}
string[] toKeep = { "Label", "Weight", "GroupId", "Comment", "Features" };
return outputTransformer.Append(new ColumnSelectingTransformer(env, toKeep, null));
}
public DataViewSchema GetOutputSchema() => _outputSchema;
public IDataView Load(IMultiStreamSource input)
{
_host.CheckValue(input, nameof(input));
var data = GetData(_host, null, input);
var indexParser = new IndexParser(_indicesKind == FeatureIndices.ZeroBased, _featureCount);
var keyVectorsToIndexVectors = _keyVectorsToIndexVectors ??
new CustomMappingTransformer<IntermediateInput, Indices>(_host, indexParser.ParseIndices, null);
data = keyVectorsToIndexVectors.Transform(data);
return CreateOutputTransformer(_host, (int)_featureCount, _indicesKind == FeatureIndices.Names, data.Schema).Transform(data);
}
// These are legacy constructors needed for ComponentCatalog.
internal static ILegacyDataLoader Create(IHostEnvironment env, ModelLoadContext ctx, IMultiStreamSource files)
{
var svmLoader = Create(env, ctx);
return new LegacyLoader(svmLoader, svmLoader.Load(files));
}
internal static ILegacyDataLoader Create(IHostEnvironment env, Options options, IMultiStreamSource files)
{
var svmLoader = new SvmLightLoader(env, options, files);
return new LegacyLoader(svmLoader, svmLoader.Load(files));
}
| Cursor |
csharp | SixLabors__Fonts | tests/SixLabors.Fonts.Tests/ImageComparison/TolerantImageComparer.cs | {
"start": 272,
"end": 5378
} | public class ____ : ImageComparer
{
// 1% of all pixels in a 100*100 pixel area are allowed to have a difference of 1 unit
// 257 = (1 / 255) * 65535.
public const float DefaultImageThreshold = 257F / (100 * 100 * 65535);
/// <summary>
/// Individual Manhattan pixel difference is only added to total image difference when the individual difference is over 'perPixelManhattanThreshold'.
/// </summary>
/// <param name="imageThreshold">The maximal tolerated difference represented by a value between 0.0 and 1.0 scaled to 0 and 65535.</param>
/// <param name="perPixelManhattanThreshold">Gets the threshold of the individual pixels before they accumulate towards the overall difference.</param>
public TolerantImageComparer(float imageThreshold, int perPixelManhattanThreshold = 0)
{
Guard.MustBeGreaterThanOrEqualTo(imageThreshold, 0, nameof(imageThreshold));
this.ImageThreshold = imageThreshold;
this.PerPixelManhattanThreshold = perPixelManhattanThreshold;
}
/// <summary>
/// <para>
/// Gets the maximal tolerated difference represented by a value between 0.0 and 1.0 scaled to 0 and 65535.
/// Examples of percentage differences on a single pixel:
/// 1. PixelA = (65535,65535,65535,0) PixelB =(0,0,0,65535) leads to 100% difference on a single pixel
/// 2. PixelA = (65535,65535,65535,0) PixelB =(65535,65535,65535,65535) leads to 25% difference on a single pixel
/// 3. PixelA = (65535,65535,65535,0) PixelB =(32767,32767,32767,32767) leads to 50% difference on a single pixel
/// </para>
/// <para>
/// The total differences is the sum of all pixel differences normalized by image dimensions!
/// The individual distances are calculated using the Manhattan function:
/// <see>
/// <cref>https://en.wikipedia.org/wiki/Taxicab_geometry</cref>
/// </see>
/// ImageThresholdInPercent = 1/255 = 257/65535 means that we allow one unit difference per channel on a 1x1 image
/// ImageThresholdInPercent = 1/(100*100*255) = 257/(100*100*65535) means that we allow only one unit difference per channel on a 100x100 image
/// </para>
/// </summary>
public float ImageThreshold { get; }
/// <summary>
/// Gets the threshold of the individual pixels before they accumulate towards the overall difference.
/// For an individual <see cref="Rgba64"/> pixel pair the value is the Manhattan distance of pixels:
/// <see>
/// <cref>https://en.wikipedia.org/wiki/Taxicab_geometry</cref>
/// </see>
/// </summary>
public int PerPixelManhattanThreshold { get; }
public override ImageSimilarityReport<TPixelA, TPixelB> CompareImagesOrFrames<TPixelA, TPixelB>(int index, ImageFrame<TPixelA> expected, ImageFrame<TPixelB> actual)
{
if (expected.Size != actual.Size)
{
throw new InvalidOperationException("Calling ImageComparer is invalid when dimensions mismatch!");
}
int width = actual.Width;
// TODO: Comparing through Rgba64 may not robust enough because of the existence of super high precision pixel types.
Rgba64[] aBuffer = new Rgba64[width];
Rgba64[] bBuffer = new Rgba64[width];
float totalDifference = 0F;
List<PixelDifference> differences = new();
Configuration configuration = expected.Configuration;
Buffer2D<TPixelA> expectedBuffer = expected.PixelBuffer;
Buffer2D<TPixelB> actualBuffer = actual.PixelBuffer;
for (int y = 0; y < actual.Height; y++)
{
Span<TPixelA> aSpan = expectedBuffer.DangerousGetRowSpan(y);
Span<TPixelB> bSpan = actualBuffer.DangerousGetRowSpan(y);
PixelOperations<TPixelA>.Instance.ToRgba64(configuration, aSpan, aBuffer);
PixelOperations<TPixelB>.Instance.ToRgba64(configuration, bSpan, bBuffer);
for (int x = 0; x < width; x++)
{
int d = GetManhattanDistanceInRgbaSpace(ref aBuffer[x], ref bBuffer[x]);
if (d > this.PerPixelManhattanThreshold)
{
PixelDifference diff = new(new Point(x, y), aBuffer[x], bBuffer[x]);
differences.Add(diff);
totalDifference += d;
}
}
}
float normalizedDifference = totalDifference / (actual.Width * (float)actual.Height);
normalizedDifference /= 4F * 65535F;
if (normalizedDifference > this.ImageThreshold)
{
return new ImageSimilarityReport<TPixelA, TPixelB>(index, expected, actual, differences, normalizedDifference);
}
return ImageSimilarityReport<TPixelA, TPixelB>.Empty;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int GetManhattanDistanceInRgbaSpace(ref Rgba64 a, ref Rgba64 b)
=> Diff(a.R, b.R) + Diff(a.G, b.G) + Diff(a.B, b.B) + Diff(a.A, b.A);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static int Diff(ushort a, ushort b) => Math.Abs(a - b);
}
| TolerantImageComparer |
csharp | RicoSuter__NJsonSchema | src/NJsonSchema.Tests/Generation/SystemTextJson/SystemTextJsonInheritanceTests.cs | {
"start": 3062,
"end": 3518
} | public class ____
{
public string Baz { get; set; }
}
[Fact]
public async Task When_using_native_attributes_and_integer_discriminator_in_SystemTextJson_then_schema_is_correct()
{
// Act
var schema = JsonSchema.FromType<Dog>();
var data = schema.ToJson().ReplaceLineEndings();
// Assert
await VerifyHelper.Verify(data);
}
#endif
}
} | Dog |
csharp | dotnet__orleans | src/Orleans.TestingHost/TestClusterOptions.cs | {
"start": 227,
"end": 6873
} | public class ____
{
/// <summary>
/// Gets or sets the cluster identifier.
/// </summary>
/// <seealso cref="ClusterOptions.ClusterId"/>
/// <value>The cluster identifier.</value>
public string ClusterId { get; set; }
/// <summary>
/// Gets or sets the service identifier.
/// </summary>
/// <seealso cref="ClusterOptions.ServiceId"/>
/// <value>The service identifier.</value>
public string ServiceId { get; set; }
/// <summary>
/// Gets or sets the base silo port, which is the port for the first silo. Other silos will use subsequent ports.
/// </summary>
/// <value>The base silo port.</value>
public int BaseSiloPort{ get; set; }
/// <summary>
/// Gets or sets the base gateway port, which is the gateway port for the first silo. Other silos will use subsequent ports.
/// </summary>
/// <value>The base gateway port.</value>
public int BaseGatewayPort { get; set; }
/// <summary>
/// Gets or sets a value indicating whether to use test cluster membership.
/// </summary>
/// <value><see langword="true" /> if test cluster membership should be used; otherwise, <see langword="false" />.</value>
public bool UseTestClusterMembership { get; set; }
/// <summary>
/// Gets or sets a value indicating whether to use the real environment statistics.
/// </summary>
public bool UseRealEnvironmentStatistics { get; set; }
/// <summary>
/// Gets or sets a value indicating whether to initialize the client immediately on deployment.
/// </summary>
/// <value><see langword="true" /> if the client should be initialized immediately on deployment; otherwise, <see langword="false" />.</value>
public bool InitializeClientOnDeploy { get; set; }
/// <summary>
/// Gets or sets the initial silos count.
/// </summary>
/// <value>The initial silos count.</value>
public short InitialSilosCount { get; set; }
/// <summary>
/// Gets or sets the application base directory.
/// </summary>
/// <value>The application base directory.</value>
public string ApplicationBaseDirectory { get; set; }
/// <summary>
/// Gets or sets a value indicating whether to configure file logging.
/// </summary>
/// <value><see langword="true" /> if file logging should be configured; otherwise, <see langword="false" />.</value>
public bool ConfigureFileLogging { get; set; } = true;
/// <summary>
/// Gets or sets a value indicating whether to assume homogeneous silos for testing purposes.
/// </summary>
/// <value><see langword="true" /> if the cluster should assume homogeneous silos; otherwise, <see langword="false" />.</value>
public bool AssumeHomogenousSilosForTesting { get; set; }
/// <summary>
/// Gets or sets a value indicating whether each silo should host a gateway.
/// </summary>
/// <value><see langword="true" /> if each silo should host a gateway; otherwise, <see langword="false" />.</value>
public bool GatewayPerSilo { get; set; } = true;
/// <summary>
/// Gets the silo builder configurator types.
/// </summary>
/// <value>The silo builder configurator types.</value>
public List<string> SiloBuilderConfiguratorTypes { get; } = new List<string>();
/// <summary>
/// Gets the client builder configurator types.
/// </summary>
/// <value>The client builder configurator types.</value>
public List<string> ClientBuilderConfiguratorTypes { get; } = new List<string>();
/// <summary>
/// Gets or sets a value indicating what transport to use for connecting silos and clients.
/// </summary>
/// <remarks>
/// Defaults to InMemory.
/// </remarks>
public ConnectionTransportType ConnectionTransport { get; set; } = ConnectionTransportType.InMemory;
/// <summary>
/// Converts these options into a dictionary.
/// </summary>
/// <returns>The options dictionary.</returns>
public Dictionary<string, string> ToDictionary()
{
var result = new Dictionary<string, string>
{
[$"Orleans:{nameof(ClusterId)}"] = this.ClusterId,
[$"Orleans:{nameof(ServiceId)}"] = this.ServiceId,
[nameof(BaseSiloPort)] = this.BaseSiloPort.ToString(),
[nameof(BaseGatewayPort)] = this.BaseGatewayPort.ToString(),
[nameof(UseTestClusterMembership)] = this.UseTestClusterMembership.ToString(),
[nameof(UseRealEnvironmentStatistics)] = this.UseRealEnvironmentStatistics.ToString(),
[nameof(InitializeClientOnDeploy)] = this.InitializeClientOnDeploy.ToString(),
[nameof(InitialSilosCount)] = this.InitialSilosCount.ToString(),
[nameof(ApplicationBaseDirectory)] = this.ApplicationBaseDirectory,
[nameof(ConfigureFileLogging)] = this.ConfigureFileLogging.ToString(),
[nameof(AssumeHomogenousSilosForTesting)] = this.AssumeHomogenousSilosForTesting.ToString(),
[nameof(GatewayPerSilo)] = this.GatewayPerSilo.ToString(),
[nameof(ConnectionTransport)] = this.ConnectionTransport.ToString(),
};
if (UseTestClusterMembership)
{
result["Orleans:Clustering:ProviderType"] = "Development";
}
result["UseRealEnvironmentStatistics"] = UseRealEnvironmentStatistics ? "True" : "False";
if (this.SiloBuilderConfiguratorTypes != null)
{
for (int i = 0; i < this.SiloBuilderConfiguratorTypes.Count; i++)
{
result[$"{nameof(SiloBuilderConfiguratorTypes)}:{i}"] = this.SiloBuilderConfiguratorTypes[i];
}
}
if (this.ClientBuilderConfiguratorTypes != null)
{
for (int i = 0; i < this.ClientBuilderConfiguratorTypes.Count; i++)
{
result[$"{nameof(ClientBuilderConfiguratorTypes)}:{i}"] = this.ClientBuilderConfiguratorTypes[i];
}
}
return result;
}
}
/// <summary>
/// Configuration overrides for individual silos.
/// </summary>
| TestClusterOptions |
csharp | dotnet__reactive | Rx.NET/Source/src/System.Reactive/Linq/Observable/CombineLatest.cs | {
"start": 14660,
"end": 15468
} | private sealed class ____ : SafeObserver<TSource>
{
private readonly _ _parent;
private readonly int _index;
public SourceObserver(_ parent, int index)
{
_parent = parent;
_index = index;
}
public override void OnNext(TSource value)
{
_parent.OnNext(_index, value);
}
public override void OnError(Exception error)
{
_parent.OnError(error);
}
public override void OnCompleted()
{
_parent.OnCompleted(_index);
}
}
}
}
#endregion
}
| SourceObserver |
csharp | dotnet__reactive | Rx.NET/Source/src/System.Reactive/Linq/Observable/OnErrorResumeNext.cs | {
"start": 293,
"end": 761
} | internal sealed class ____<TSource> : Producer<TSource, OnErrorResumeNext<TSource>._>
{
private readonly IEnumerable<IObservable<TSource>> _sources;
public OnErrorResumeNext(IEnumerable<IObservable<TSource>> sources)
{
_sources = sources;
}
protected override _ CreateSink(IObserver<TSource> observer) => new(observer);
protected override void Run(_ sink) => sink.Run(_sources);
| OnErrorResumeNext |
csharp | ChilliCream__graphql-platform | src/Nitro/CommandLine/src/CommandLine.Cloud/Generated/ApiClient.Client.cs | {
"start": 678350,
"end": 679016
} | public partial interface ____ : ISchemaChange
{
public global::System.String Coordinate { get; }
public global::System.String Name { get; }
/// <summary>
/// The name of the current Object type at runtime.
/// </summary>
public global::System.String __typename { get; }
public global::System.Collections.Generic.IReadOnlyList<global::ChilliCream.Nitro.CommandLine.Cloud.Client.IOnClientVersionPublishUpdated_OnClientVersionPublishingUpdate_Deployment_Errors_Changes_Changes_Changes> Changes { get; }
}
[global::System.CodeDom.Compiler.GeneratedCode("StrawberryShake", "15.1.8.0")]
| IArgumentChanged |
csharp | smartstore__Smartstore | src/Smartstore.Web/Areas/Admin/Models/Orders/OrderModel.cs | {
"start": 5073,
"end": 5349
} | public class ____ : ModelBase
{
[LocalizedDisplay("Admin.Orders.Fields.GiftCardInfo")]
public string CouponCode { get; set; }
public string Amount { get; set; }
public int GiftCardId { get; set; }
}
| GiftCard |
csharp | dotnet__reactive | Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs | {
"start": 49459,
"end": 54088
} | private sealed class ____<TSource, TKey, TElement, TResult> : AsyncIterator<TResult>, IAsyncIListProvider<TResult>
{
private readonly IAsyncEnumerable<TSource> _source;
private readonly Func<TSource, ValueTask<TKey>> _keySelector;
private readonly Func<TSource, ValueTask<TElement>> _elementSelector;
private readonly Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> _resultSelector;
private readonly IEqualityComparer<TKey>? _comparer;
private Internal.LookupWithTask<TKey, TElement>? _lookup;
private IAsyncEnumerator<TResult>? _enumerator;
public GroupedResultAsyncEnumerableWithTask(IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey>? comparer)
{
_source = source ?? throw Error.ArgumentNull(nameof(source));
_keySelector = keySelector ?? throw Error.ArgumentNull(nameof(keySelector));
_elementSelector = elementSelector ?? throw Error.ArgumentNull(nameof(elementSelector));
_resultSelector = resultSelector ?? throw Error.ArgumentNull(nameof(resultSelector));
_comparer = comparer;
}
public override AsyncIteratorBase<TResult> Clone()
{
return new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(_source, _keySelector, _elementSelector, _resultSelector, _comparer);
}
public override async ValueTask DisposeAsync()
{
if (_enumerator != null)
{
await _enumerator.DisposeAsync().ConfigureAwait(false);
_enumerator = null;
_lookup = null;
}
await base.DisposeAsync().ConfigureAwait(false);
}
protected override async ValueTask<bool> MoveNextCore()
{
switch (_state)
{
case AsyncIteratorState.Allocated:
_lookup = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, _cancellationToken).ConfigureAwait(false);
_enumerator = _lookup.SelectAwaitCore(async g => await _resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
_state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
if (await _enumerator!.MoveNextAsync().ConfigureAwait(false))
{
_current = _enumerator.Current;
return true;
}
await DisposeAsync().ConfigureAwait(false);
break;
}
return false;
}
public async ValueTask<TResult[]> ToArrayAsync(CancellationToken cancellationToken)
{
var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
return await l.ToArray(_resultSelector).ConfigureAwait(false);
}
public async ValueTask<List<TResult>> ToListAsync(CancellationToken cancellationToken)
{
var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
return await l.ToList(_resultSelector).ConfigureAwait(false);
}
public ValueTask<int> GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken)
{
if (onlyIfCheap)
{
return new ValueTask<int>(-1);
}
return Core();
async ValueTask<int> Core()
{
var l = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, cancellationToken).ConfigureAwait(false);
return l.Count;
}
}
}
#if !NO_DEEP_CANCELLATION
| GroupedResultAsyncEnumerableWithTask |
csharp | ardalis__CleanArchitecture | MinimalClean/src/MinimalClean.Architecture.Web/Infrastructure/Data/SeedData.cs | {
"start": 197,
"end": 989
} | public static class ____
{
public const int NUMBER_OF_PRODUCTS = 10;
public static async Task InitializeAsync(AppDbContext dbContext, ILogger logger)
{
if (await dbContext.Products.AnyAsync())
{
logger.LogInformation("DB has data - seeding not required.");
return; // DB has been seeded
}
await PopulateTestDataAsync(dbContext, logger);
}
public static async Task PopulateTestDataAsync(AppDbContext dbContext, ILogger logger)
{
logger.LogInformation("Seeding database with sample data.");
// add more products to support demonstrating paging
for (int i = 1; i <= NUMBER_OF_PRODUCTS; i++)
{
dbContext.Products.Add(new Product(ProductId.From(i), $"Product {i}", 10m + i));
}
await dbContext.SaveChangesAsync();
}
}
| SeedData |
csharp | dotnet__orleans | test/Grains/TestGrainInterfaces/IRequestContextTestGrain.cs | {
"start": 330,
"end": 777
} | public interface ____ : IGrainWithIntegerKey
{
Task<string> TraceIdEcho();
Task<string> TraceIdDoubleEcho();
Task<string> TraceIdDelayedEcho1();
Task<string> TraceIdDelayedEcho2();
Task<string> TraceIdDelayedEchoAwait();
Task<string> TraceIdDelayedEchoTaskRun();
Task<Guid> E2EActivityId();
Task<Tuple<string, string>> TestRequestContext();
}
| IRequestContextTaskGrain |
csharp | nuke-build__nuke | source/Nuke.Build.Tests/SchemaUtilityTest.cs | {
"start": 3485,
"end": 3636
} | private class ____ : NukeBuild
{
[CustomParameter] readonly ComplexType ComplexTypeParamWithAttribute;
}
| CustomParameterAttributeBuild |
csharp | nuke-build__nuke | source/Nuke.Utilities/Text/String.KnownWords.cs | {
"start": 184,
"end": 495
} | partial class ____
{
private static readonly string[] KnownWords =
{
"DotNet",
"GitHub",
"GitVersion",
"MSBuild",
"NuGet",
"ReSharper",
"AppVeyor",
"TeamCity",
"GitLab",
"SignPath",
"JetBrains"
};
} | StringExtensions |
csharp | dotnet__extensions | test/Analyzers/Microsoft.Analyzers.Local.Tests/ApiLifecycle/AnalysisModelTest.cs | {
"start": 295,
"end": 2586
} | public class ____
{
[Fact]
public void Field_Fallbacks_To_NotNull_Defaults_When_Value_Not_Found_In_Json()
{
var field = new Field([]);
Assert.Equal(string.Empty, field.Member);
Assert.Equal(Stage.Experimental, field.Stage);
}
[Fact]
public void PublicMember_Fallbacks_To_NotNull_Defaults_When_Value_Not_Found_In_Json()
{
var member = new TypeDef([]);
Assert.Equal(string.Empty, member.ModifiersAndName);
Assert.Equal(Stage.Experimental, member.Stage);
Assert.Equal(Array.Empty<Field>(), member.Fields);
Assert.Equal(Array.Empty<string>(), member.BaseTypes);
Assert.Equal(Array.Empty<string>(), member.Constraints);
Assert.Equal(Array.Empty<Method>(), member.Methods);
Assert.Equal(Array.Empty<Prop>(), member.Properties);
}
[Fact]
public void Prop_Fallbacks_To_NotNull_Defaults_When_Value_Not_Found_In_Json()
{
var prop = new Prop([]);
Assert.Equal(string.Empty, prop.Member);
Assert.Equal(Stage.Experimental, prop.Stage);
}
[Fact]
public void PackageAnalysis_Fallbacks_To_NotNull_Defaults_When_Value_Not_Found_In_Json()
{
var analysis = new AssemblyAnalysis(Assembly.Empty);
Assert.Equal(Assembly.Empty, analysis.Assembly);
Assert.Empty(analysis.MissingProperties);
Assert.Empty(analysis.MissingBaseTypes);
Assert.Empty(analysis.FoundInBaseline);
Assert.Empty(analysis.NotFoundInBaseline);
Assert.Empty(analysis.MissingTypes);
Assert.Empty(analysis.MissingConstraints);
Assert.Empty(analysis.MissingFields);
Assert.Empty(analysis.MissingMethods);
Assert.Empty(analysis.MissingProperties);
}
[Fact]
public void Package_Fallbacks_To_NotNull_Defaults_When_Value_Not_Found_In_Json()
{
var package = new Assembly([]);
Assert.Equal(Array.Empty<TypeDef>(), package.Types);
Assert.Equal(string.Empty, package.Name);
}
[Fact]
public void Method_FallbacksTo_NotNull_Defaults_When_Value_Not_Found_In_Json()
{
var method = new Method([]);
Assert.Equal(string.Empty, method.Member);
Assert.Equal(Stage.Experimental, method.Stage);
}
}
| AnalysisModelTest |
csharp | MahApps__MahApps.Metro | src/MahApps.Metro/Controls/MultiSelectionComboBox/SelectedItemsOrderType.cs | {
"start": 351,
"end": 714
} | public enum ____
{
/// <summary>
/// Displays the selected items in the same order as they were selected
/// </summary>
SelectedOrder,
/// <summary>
/// Displays the selected items in the same order as they are stored in the ItemsSource
/// </summary>
ItemsSourceOrder
}
} | SelectedItemsOrderType |
csharp | dotnet__orleans | test/Orleans.CodeGenerator.Tests/snapshots/OrleansSourceGeneratorTests.TestClassWithOptionalConstructorParameters.verified.cs | {
"start": 7286,
"end": 10638
} | public sealed class ____ : global::Orleans.Serialization.Cloning.IDeepCopier<global::TestProject.OptionalCtorParams>, global::Orleans.Serialization.Cloning.IBaseCopier<global::TestProject.OptionalCtorParams>
{
private readonly global::Orleans.Serialization.Activators.IActivator<global::TestProject.OptionalCtorParams> _activator;
private static readonly global::System.Func<global::TestProject.OptionalCtorParams, int> getField0 = (global::System.Func<global::TestProject.OptionalCtorParams, int>)global::Orleans.Serialization.Utilities.FieldAccessor.GetGetter(typeof(global::TestProject.OptionalCtorParams), "_x");
private static readonly global::System.Action<global::TestProject.OptionalCtorParams, int> setField0 = (global::System.Action<global::TestProject.OptionalCtorParams, int>)global::Orleans.Serialization.Utilities.FieldAccessor.GetReferenceSetter(typeof(global::TestProject.OptionalCtorParams), "_x");
private static readonly global::System.Func<global::TestProject.OptionalCtorParams, string> getField1 = (global::System.Func<global::TestProject.OptionalCtorParams, string>)global::Orleans.Serialization.Utilities.FieldAccessor.GetGetter(typeof(global::TestProject.OptionalCtorParams), "_y");
private static readonly global::System.Action<global::TestProject.OptionalCtorParams, string> setField1 = (global::System.Action<global::TestProject.OptionalCtorParams, string>)global::Orleans.Serialization.Utilities.FieldAccessor.GetReferenceSetter(typeof(global::TestProject.OptionalCtorParams), "_y");
[global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
public global::TestProject.OptionalCtorParams DeepCopy(global::TestProject.OptionalCtorParams original, global::Orleans.Serialization.Cloning.CopyContext context)
{
if (context.TryGetCopy(original, out global::TestProject.OptionalCtorParams existing))
return existing;
if (original.GetType() != typeof(global::TestProject.OptionalCtorParams))
return context.DeepCopy(original);
var result = _activator.Create();
context.RecordCopy(original, result);
DeepCopy(original, result, context);
return result;
}
public Copier_OptionalCtorParams(global::Orleans.Serialization.Activators.IActivator<global::TestProject.OptionalCtorParams> _activator)
{
this._activator = OrleansGeneratedCodeHelper.UnwrapService(this, _activator);
}
[global::System.Runtime.CompilerServices.MethodImplAttribute(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
public void DeepCopy(global::TestProject.OptionalCtorParams input, global::TestProject.OptionalCtorParams output, global::Orleans.Serialization.Cloning.CopyContext context)
{
setField0(output, getField0(input));
setField1(output, getField1(input));
}
}
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("OrleansCodeGen", "10.0.0.0"), global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Never), global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
| Copier_OptionalCtorParams |
csharp | nopSolutions__nopCommerce | src/Plugins/Nop.Plugin.Payments.PayPalCommerce/Services/Api/PaymentTokens/DeletePaymentTokenRequest.cs | {
"start": 214,
"end": 758
} | public class ____ : IAuthorizedRequest
{
#region Properties
/// <summary>
/// Gets or sets the ID of the payment token.
/// </summary>
[JsonIgnore]
public string Id { get; set; }
/// <summary>
/// Gets the request path
/// </summary>
[JsonIgnore]
public string Path => $"v3/vault/payment-tokens/{Uri.EscapeDataString(Id)}?";
/// <summary>
/// Gets the request method
/// </summary>
[JsonIgnore]
public string Method => HttpMethods.Delete;
#endregion
} | DeletePaymentTokenRequest |
csharp | louthy__language-ext | LanguageExt.Core/Monads/Alternative Monads/Either/Operators/Either.Operators.Monad.cs | {
"start": 78,
"end": 1609
} | partial class ____
{
extension<L, A, B>(K<Either<L>, A> self)
{
/// <summary>
/// Monad bind operator
/// </summary>
/// <param name="ma">Monad to bind</param>
/// <param name="f">Binding function</param>
/// <returns>Mapped monad</returns>
public static Either<L, B> operator >> (K<Either<L>, A> ma, Func<A, K<Either<L>, B>> f) =>
ma.Bind(f).As();
/// <summary>
/// Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such
/// as the semicolon) in C#.
/// </summary>
/// <param name="lhs">First action to run</param>
/// <param name="rhs">Second action to run</param>
/// <returns>Result of the second action</returns>
public static Either<L, B> operator >> (K<Either<L>, A> lhs, K<Either<L>, B> rhs) =>
lhs >> (_ => rhs);
}
extension<L, A>(K<Either<L>, A> self)
{
/// <summary>
/// Sequentially compose two actions. The second action is a unit-returning action, so the result of the
/// first action is propagated.
/// </summary>
/// <param name="lhs">First action to run</param>
/// <param name="rhs">Second action to run</param>
/// <returns>Result of the first action</returns>
public static Either<L, A> operator >> (K<Either<L>, A> lhs, K<Either<L>, Unit> rhs) =>
lhs >> (x => (_ => x) * rhs);
}
}
| EitherExtensions |
csharp | louthy__language-ext | LanguageExt.Streaming/Pipes/PipeT/PipeT.DSL.cs | {
"start": 4871,
"end": 6608
} | record ____<IN, OUT, M, A>(Func<PipeT<IN, OUT, M, A>> Acquire) : PipeT<IN, OUT, M, A>
where M : MonadIO<M>
{
public override PipeT<IN, OUT, M, B> Map<B>(Func<A, B> f) =>
new PipeTLazy<IN, OUT, M, B>(() => Acquire().Map(f));
public override PipeT<IN, OUT, M, B> MapM<B>(Func<K<M, A>, K<M, B>> f) =>
new PipeTLazy<IN, OUT, M, B>(() => Acquire().MapM(f));
public override PipeT<IN, OUT, M, B> ApplyBack<B>(PipeT<IN, OUT, M, Func<A, B>> ff) =>
new PipeTLazy<IN, OUT, M, B>(() => Acquire().ApplyBack(ff));
public override PipeT<IN, OUT, M, B> Action<B>(PipeT<IN, OUT, M, B> fb) =>
new PipeTLazy<IN, OUT, M, B>(() => Acquire().Action(fb));
public override PipeT<IN, OUT, M, B> Bind<B>(Func<A, PipeT<IN, OUT, M, B>> f) =>
new PipeTLazy<IN, OUT, M, B>(() => Acquire().Bind(f));
internal override PipeT<IN1, OUT, M, A> ReplaceAwait<IN1>(Func<PipeT<IN1, OUT, M, IN>> producer) =>
new PipeTLazy<IN1, OUT, M, A>(() => Acquire().ReplaceAwait(producer));
internal override PipeT<IN, OUT1, M, A> ReplaceYield<OUT1>(Func<OUT, PipeT<IN, OUT1, M, Unit>> consumer) =>
new PipeTLazy<IN, OUT1, M, A>(() => Acquire().ReplaceYield(consumer));
internal override PipeT<IN1, OUT, M, A> PairEachAwaitWithYield<IN1>(Func<Unit, PipeT<IN1, IN, M, A>> producer) =>
new PipeTLazy<IN1, OUT, M, A>(() => Acquire().PairEachAwaitWithYield(producer));
internal override PipeT<IN, OUT1, M, A> PairEachYieldWithAwait<OUT1>(Func<OUT, PipeT<OUT, OUT1, M, A>> consumer) =>
new PipeTLazy<IN, OUT1, M, A>(() => Acquire().PairEachYieldWithAwait(consumer));
internal override ValueTask<K<M, A>> RunAsync() =>
Acquire().RunAsync();
}
| PipeTLazy |
csharp | smartstore__Smartstore | src/Smartstore.Core/Checkout/Permissions.Checkout.cs | {
"start": 96,
"end": 637
} | public static class ____
{
public const string Self = "order";
public const string Read = "order.read";
public const string Update = "order.update";
public const string Create = "order.create";
public const string Delete = "order.delete";
public const string EditItem = "order.editorderitem";
public const string EditShipment = "order.editshipment";
public const string EditRecurringPayment = "order.editrecurringpayment";
| Order |
csharp | cake-build__cake | src/Cake.Frosting/Annotations/TaskNameAttribute.cs | {
"start": 427,
"end": 880
} | public sealed class ____ : Attribute
{
/// <summary>
/// Gets the task name.
/// </summary>
public string Name { get; }
/// <summary>
/// Initializes a new instance of the <see cref="TaskNameAttribute"/> class.
/// </summary>
/// <param name="name">The task name.</param>
public TaskNameAttribute(string name)
{
Name = name;
}
}
}
| TaskNameAttribute |
csharp | ardalis__Specification | tests/Ardalis.Specification.Tests/Evaluators/InMemorySpecificationEvaluatorTests.cs | {
"start": 269,
"end": 7030
} | public record ____(int Id, string FirstName, string LastName, List<string> Emails);
[Fact]
public void Evaluate_ThrowsSelectorNotFoundException_GivenNoSelector()
{
var spec = new Specification<Customer, string>();
var sut = () => _evaluator.Evaluate([], spec);
sut.Should().Throw<SelectorNotFoundException>();
}
[Fact]
public void Evaluate_ThrowsConcurrentSelectorsException_GivenSelectAndSelectMany()
{
var spec = new Specification<CustomerWithMails, string>();
spec.Query.Select(x => x.FirstName);
spec.Query.SelectMany(x => x.Emails);
var sut = () => _evaluator.Evaluate([], spec);
sut.Should().Throw<ConcurrentSelectorsException>();
}
[Fact]
public void Evaluate_Filters_GivenSpec()
{
List<Customer> input =
[
new(1, "axxa", "axya"),
new(2, "aaaa", "axya"),
new(3, "aaaa", "axya"),
new(4, "aaaa", "axya")
];
List<Customer> expected =
[
new(3, "aaaa", "axya")
];
var spec = new Specification<Customer>();
spec.Query
.Where(x => x.Id > 1)
.Search(x => x.LastName, "%xy%")
.OrderBy(x => x.Id)
.Skip(1)
.Take(1);
var actual = _evaluator.Evaluate(input, spec).ToList();
var actualFromSpec = spec.Evaluate(input).ToList();
actual.Should().Equal(actualFromSpec);
actual.Should().Equal(expected);
}
[Fact]
public void Evaluate_Filters_GivenSpecWithSelect()
{
List<Customer> input =
[
new(1, "axxa", "axya"),
new(2, "aaaa", "axya"),
new(3, "vvvv", "axya"),
new(4, "aaaa", "axya")
];
List<string> expected = ["vvvv"];
var spec = new Specification<Customer, string>();
spec.Query
.Where(x => x.Id > 1)
.Search(x => x.LastName, "%xy%")
.OrderBy(x => x.Id)
.Skip(1)
.Take(1)
.Select(x => x.FirstName);
var actual = _evaluator.Evaluate(input, spec).ToList();
var actualFromSpec = spec.Evaluate(input).ToList();
actual.Should().Equal(actualFromSpec);
actual.Should().Equal(expected);
}
[Fact]
public void Evaluate_Filters_GivenSpecWithSelectMany()
{
List<CustomerWithMails> input =
[
new(1, "axxa", "axya", []),
new(2, "aaaa", "axya", []),
new(3, "aaaa", "axya", ["zzz", "www"]),
new(4, "aaaa", "axya", ["yyy"])
];
// TODO: This is a known flaw. Pagination should be applied after SelectMany [Fati, 11/03/2025]
// It's a major breaking change, so it will be postponed to v10.
List<string> expected = ["zzz", "www", "yyy"];
var spec = new Specification<CustomerWithMails, string>();
spec.Query
.Where(x => x.Id > 1)
.Search(x => x.LastName, "%xy%")
.OrderBy(x => x.Id)
.Skip(1)
.Take(2)
.SelectMany(x => x.Emails);
var actual = _evaluator.Evaluate(input, spec).ToList();
var actualFromSpec = spec.Evaluate(input).ToList();
actual.Should().Equal(actualFromSpec);
actual.Should().Equal(expected);
}
[Fact]
public void Evaluate_Filters_GivenSpecAndPostProcessingAction()
{
List<Customer> input =
[
new(1, "axxa", "axya"),
new(2, "aaaa", "axya"),
new(3, "aaaa", "axya"),
new(4, "aaaa", "axya")
];
List<Customer> expected =
[
new(3, "aaaa", "axya")
];
var spec = new Specification<Customer>();
spec.Query
.Where(x => x.Id > 1)
.PostProcessingAction(x => x.Where(c => c.Id == 3));
var actual = _evaluator.Evaluate(input, spec).ToList();
var actualFromSpec = spec.Evaluate(input).ToList();
actual.Should().Equal(actualFromSpec);
actual.Should().Equal(expected);
}
[Fact]
public void Evaluate_Filters_GivenSpecWithSelectAndPostProcessingAction()
{
List<Customer> input =
[
new(1, "axxa", "axya"),
new(2, "aaaa", "axya"),
new(3, "vvvv", "axya"),
new(4, "aaaa", "axya")
];
List<string> expected = ["vvvv"];
var spec = new Specification<Customer, string>();
spec.Query
.Where(x => x.Id > 1)
.PostProcessingAction(x => x.Where(c => c == "vvvv"))
.Select(x => x.FirstName);
var actual = _evaluator.Evaluate(input, spec).ToList();
var actualFromSpec = spec.Evaluate(input).ToList();
actual.Should().Equal(actualFromSpec);
actual.Should().Equal(expected);
}
[Fact]
public void Evaluate_DoesNotFilter_GivenEmptySpec()
{
List<Customer> input =
[
new(1, "axxa", "axya"),
new(2, "aaaa", "axya"),
new(3, "aaaa", "axya"),
new(4, "aaaa", "axya")
];
List<Customer> expected =
[
new(1, "axxa", "axya"),
new(2, "aaaa", "axya"),
new(3, "aaaa", "axya"),
new(4, "aaaa", "axya")
];
var spec = new Specification<Customer>();
var actual = _evaluator.Evaluate(input, spec).ToList();
var actualFromSpec = spec.Evaluate(input).ToList();
actual.Should().Equal(actualFromSpec);
actual.Should().Equal(expected);
}
#if NET8_0_OR_GREATER
[Fact]
public void Constructor_SetsProvidedEvaluators()
{
var evaluators = new List<IInMemoryEvaluator>
{
WhereEvaluator.Instance,
OrderEvaluator.Instance,
WhereEvaluator.Instance,
};
var evaluator = new InMemorySpecificationEvaluator(evaluators);
var result = EvaluatorsOf(evaluator);
result.Should().HaveSameCount(evaluators);
result.Should().Equal(evaluators);
}
[Fact]
public void DerivedSpecificationEvaluatorCanAlterDefaultEvaluator()
{
var evaluator = new SpecificationEvaluatorDerived();
var result = EvaluatorsOf(evaluator);
result.Should().HaveCount(6);
result[0].Should().BeOfType<SearchMemoryEvaluator>();
result[1].Should().BeOfType<WhereEvaluator>();
result[2].Should().BeOfType<SearchMemoryEvaluator>();
result[3].Should().BeOfType<OrderEvaluator>();
result[4].Should().BeOfType<PaginationEvaluator>();
result[5].Should().BeOfType<WhereEvaluator>();
}
| CustomerWithMails |
csharp | AvaloniaUI__Avalonia | src/Avalonia.Vulkan/Interop/VulkanCommandBufferPool.cs | {
"start": 125,
"end": 2622
} | internal class ____ : IDisposable
{
private readonly IVulkanPlatformGraphicsContext _context;
private readonly bool _autoFree;
private readonly Queue<VulkanCommandBuffer> _commandBuffers = new();
private VkCommandPool _handle;
public VkCommandPool Handle => _handle;
public VulkanCommandBufferPool(IVulkanPlatformGraphicsContext context, bool autoFree = false)
{
_context = context;
_autoFree = autoFree;
var createInfo = new VkCommandPoolCreateInfo
{
sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
flags = VkCommandPoolCreateFlags.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
queueFamilyIndex = context.GraphicsQueueFamilyIndex
};
_context.DeviceApi.CreateCommandPool(_context.DeviceHandle, ref createInfo, IntPtr.Zero, out _handle)
.ThrowOnError("vkCreateCommandPool");
}
public void FreeUsedCommandBuffers()
{
while (_commandBuffers.Count > 0)
_commandBuffers.Dequeue().Dispose();
}
public void FreeFinishedCommandBuffers()
{
while (_commandBuffers.Count > 0)
{
var next = _commandBuffers.Peek();
if(!next.IsFinished)
return;
_commandBuffers.Dequeue();
next.Dispose();
}
}
public void Dispose()
{
FreeUsedCommandBuffers();
if (_handle.Handle != 0)
_context.DeviceApi.DestroyCommandPool(_context.DeviceHandle, _handle, IntPtr.Zero);
_handle = default;
}
public unsafe VulkanCommandBuffer CreateCommandBuffer()
{
if (_autoFree)
FreeFinishedCommandBuffers();
var commandBufferAllocateInfo = new VkCommandBufferAllocateInfo
{
sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
commandPool = _handle,
commandBufferCount = 1,
level = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY
};
VkCommandBuffer bufferHandle = default;
_context.DeviceApi.AllocateCommandBuffers(_context.DeviceHandle, ref commandBufferAllocateInfo,
&bufferHandle).ThrowOnError("vkAllocateCommandBuffers");
return new VulkanCommandBuffer(this, bufferHandle, _context);
}
public void AddSubmittedCommandBuffer(VulkanCommandBuffer buffer) => _commandBuffers.Enqueue(buffer);
} | VulkanCommandBufferPool |
csharp | bitwarden__server | test/Core.Test/AdminConsole/Services/OrganizationServiceTests.cs | {
"start": 1572,
"end": 68329
} | public class ____
{
private readonly IDataProtectorTokenFactory<OrgUserInviteTokenable> _orgUserInviteTokenDataFactory = new FakeDataProtectorTokenFactory<OrgUserInviteTokenable>();
[Theory]
[OrganizationInviteCustomize(InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Owner), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_NoEmails_Throws(Organization organization, OrganizationUser invitor,
OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
{
invite.Emails = null;
sutProvider.GetDependency<ICurrentContext>().OrganizationOwner(organization.Id).Returns(true);
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
await Assert.ThrowsAsync<NotFoundException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
}
[Theory]
[OrganizationInviteCustomize, OrganizationCustomize, BitAutoData]
public async Task InviteUsers_DuplicateEmails_PassesWithoutDuplicates(Organization organization, OrganizationUser invitor,
[OrganizationUser(OrganizationUserStatusType.Confirmed, OrganizationUserType.Owner)] OrganizationUser owner,
OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
{
// Setup FakeDataProtectorTokenFactory for creating new tokens - this must come first in order to avoid resetting mocks
sutProvider.SetDependency(_orgUserInviteTokenDataFactory, "orgUserInviteTokenDataFactory");
sutProvider.Create();
invite.Emails = invite.Emails.Append(invite.Emails.First());
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<ICurrentContext>().OrganizationOwner(organization.Id).Returns(true);
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
organizationUserRepository.GetManyByOrganizationAsync(organization.Id, OrganizationUserType.Owner)
.Returns(new[] { owner });
// Must set guids in order for dictionary of guids to not throw aggregate exceptions
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
await sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) });
await sutProvider.GetDependency<ISendOrganizationInvitesCommand>().Received(1)
.SendInvitesAsync(Arg.Is<SendInvitesRequest>(request =>
request.Users.DistinctBy(x => x.Email).Count() == invite.Emails.Distinct().Count() &&
request.Organization == organization));
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Admin,
InvitorUserType = OrganizationUserType.Owner
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_NoOwner_Throws(Organization organization, OrganizationUser invitor,
OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
{
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<ICurrentContext>().OrganizationOwner(organization.Id).Returns(true);
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
Assert.Contains("Organization must have at least one confirmed owner.", exception.Message);
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Owner,
InvitorUserType = OrganizationUserType.Admin
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_NonOwnerConfiguringOwner_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
currentContext.OrganizationAdmin(organization.Id).Returns(true);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
Assert.Contains("only an owner", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Custom,
InvitorUserType = OrganizationUserType.User
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_NonAdminConfiguringAdmin_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
organization.UseCustomPermissions = true;
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
currentContext.OrganizationUser(organization.Id).Returns(true);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
Assert.Contains("your account does not have permission to manage users", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Custom,
InvitorUserType = OrganizationUserType.Admin
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_WithCustomType_WhenUseCustomPermissionsIsFalse_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
organization.UseCustomPermissions = false;
invite.Permissions = null;
invitor.Status = OrganizationUserStatusType.Confirmed;
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
organizationUserRepository.GetManyByOrganizationAsync(organization.Id, OrganizationUserType.Owner)
.Returns(new[] { invitor });
currentContext.OrganizationOwner(organization.Id).Returns(true);
currentContext.ManageUsers(organization.Id).Returns(true);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
Assert.Contains("to enable custom permissions", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Custom,
InvitorUserType = OrganizationUserType.Admin
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_WithCustomType_WhenUseCustomPermissionsIsTrue_Passes(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
organization.Seats = 10;
organization.UseCustomPermissions = true;
invite.Permissions = null;
invitor.Status = OrganizationUserStatusType.Confirmed;
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
currentContext.OrganizationOwner(organization.Id).Returns(true);
currentContext.ManageUsers(organization.Id).Returns(true);
await sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) });
}
[Theory]
[BitAutoData(OrganizationUserType.Admin)]
[BitAutoData(OrganizationUserType.Owner)]
[BitAutoData(OrganizationUserType.User)]
public async Task InviteUsers_WithNonCustomType_WhenUseCustomPermissionsIsFalse_Passes(OrganizationUserType inviteUserType, Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
organization.Seats = 10;
organization.UseCustomPermissions = false;
invite.Type = inviteUserType;
invite.Permissions = null;
invitor.Status = OrganizationUserStatusType.Confirmed;
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
currentContext.OrganizationOwner(organization.Id).Returns(true);
currentContext.ManageUsers(organization.Id).Returns(true);
await sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) });
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_CustomUserWithoutManageUsersConfiguringUser_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
invitor.Permissions = JsonSerializer.Serialize(new Permissions() { ManageUsers = false },
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
currentContext.OrganizationCustom(organization.Id).Returns(true);
currentContext.ManageUsers(organization.Id).Returns(false);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
Assert.Contains("account does not have permission", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Admin,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_CustomUserConfiguringAdmin_Throws(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
invitor.Permissions = JsonSerializer.Serialize(new Permissions() { ManageUsers = true },
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
currentContext.OrganizationCustom(organization.Id).Returns(true);
currentContext.ManageUsers(organization.Id).Returns(true);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) }));
Assert.Contains("can not manage admins", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Owner
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_NoPermissionsObject_Passes(Organization organization, OrganizationUserInvite invite,
OrganizationUser invitor, SutProvider<OrganizationService> sutProvider)
{
invite.Permissions = null;
invitor.Status = OrganizationUserStatusType.Confirmed;
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
currentContext.OrganizationOwner(organization.Id).Returns(true);
currentContext.ManageUsers(organization.Id).Returns(true);
await sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, new (OrganizationUserInvite, string)[] { (invite, null) });
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUser_Passes(Organization organization, OrganizationUserInvite invite, string externalId,
OrganizationUser invitor,
SutProvider<OrganizationService> sutProvider)
{
// This method is only used to invite 1 user at a time
invite.Emails = new[] { invite.Emails.First() };
// Setup FakeDataProtectorTokenFactory for creating new tokens - this must come first in order to avoid resetting mocks
sutProvider.SetDependency(_orgUserInviteTokenDataFactory, "orgUserInviteTokenDataFactory");
sutProvider.Create();
InviteUser_ArrangeCurrentContextPermissions(organization, sutProvider);
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
// Mock tokenable factory to return a token that expires in 5 days
// sutProvider.GetDependency<IOrgUserInviteTokenableFactory>()
// .CreateToken(Arg.Any<OrganizationUser>())
// .Returns(
// info => new OrgUserInviteTokenable(info.Arg<OrganizationUser>())
// {
// ExpirationDate = DateTime.UtcNow.Add(TimeSpan.FromDays(5))
// }
// );
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
SetupOrgUserRepositoryCreateAsyncMock(organizationUserRepository);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
await sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, systemUser: null, invite, externalId);
await sutProvider.GetDependency<ISendOrganizationInvitesCommand>().Received(1)
.SendInvitesAsync(Arg.Is<SendInvitesRequest>(request =>
request.Users.Length == 1 &&
request.Organization == organization));
await sutProvider.GetDependency<IEventService>().Received(1).LogOrganizationUserEventsAsync(Arg.Any<IEnumerable<(OrganizationUser, EventType, DateTime?)>>());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUser_InvitingMoreThanOneUser_Throws(Organization organization, OrganizationUserInvite invite, string externalId,
OrganizationUser invitor,
SutProvider<OrganizationService> sutProvider)
{
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.InviteUserAsync(organization.Id, invitor.UserId, systemUser: null, invite, externalId));
Assert.Contains("This method can only be used to invite a single user.", exception.Message);
await sutProvider.GetDependency<IMailService>().DidNotReceiveWithAnyArgs()
.SendOrganizationInviteEmailsAsync(default);
await sutProvider.GetDependency<IEventService>().DidNotReceive()
.LogOrganizationUserEventsAsync(Arg.Any<IEnumerable<(OrganizationUser, EventType, EventSystemUser, DateTime?)>>());
await sutProvider.GetDependency<IEventService>().DidNotReceive()
.LogOrganizationUserEventsAsync(Arg.Any<IEnumerable<(OrganizationUser, EventType, DateTime?)>>());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUser_UserAlreadyInvited_Throws(Organization organization, OrganizationUserInvite invite, string externalId,
OrganizationUser invitor,
SutProvider<OrganizationService> sutProvider)
{
// This method is only used to invite 1 user at a time
invite.Emails = new[] { invite.Emails.First() };
// The user has already been invited
sutProvider.GetDependency<IOrganizationUserRepository>()
.SelectKnownEmailsAsync(organization.Id, Arg.Any<IEnumerable<string>>(), false)
.Returns(new List<string> { invite.Emails.First() });
// Setup FakeDataProtectorTokenFactory for creating new tokens - this must come first in order to avoid resetting mocks
sutProvider.SetDependency(_orgUserInviteTokenDataFactory, "orgUserInviteTokenDataFactory");
sutProvider.Create();
InviteUser_ArrangeCurrentContextPermissions(organization, sutProvider);
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
SetupOrgUserRepositoryCreateAsyncMock(organizationUserRepository);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut
.InviteUserAsync(organization.Id, invitor.UserId, systemUser: null, invite, externalId));
Assert.Contains("This user has already been invited", exception.Message);
// SendOrganizationInvitesCommand and EventService are still called, but with no OrgUsers
await sutProvider.GetDependency<ISendOrganizationInvitesCommand>().Received(1)
.SendInvitesAsync(Arg.Is<SendInvitesRequest>(info =>
info.Organization == organization &&
info.Users.Length == 0));
await sutProvider.GetDependency<IEventService>().Received(1)
.LogOrganizationUserEventsAsync(Arg.Is<IEnumerable<(OrganizationUser, EventType, DateTime?)>>(events => !events.Any()));
}
private void InviteUser_ArrangeCurrentContextPermissions(Organization organization, SutProvider<OrganizationService> sutProvider)
{
var currentContext = sutProvider.GetDependency<ICurrentContext>();
currentContext.ManageUsers(organization.Id).Returns(true);
currentContext.AccessReports(organization.Id).Returns(true);
currentContext.ManageGroups(organization.Id).Returns(true);
currentContext.ManagePolicies(organization.Id).Returns(true);
currentContext.ManageScim(organization.Id).Returns(true);
currentContext.ManageSso(organization.Id).Returns(true);
currentContext.AccessEventLogs(organization.Id).Returns(true);
currentContext.AccessImportExport(organization.Id).Returns(true);
currentContext.EditAnyCollection(organization.Id).Returns(true);
currentContext.ManageResetPassword(organization.Id).Returns(true);
currentContext.GetOrganization(organization.Id)
.Returns(new CurrentContextOrganization()
{
Permissions = new Permissions
{
CreateNewCollections = true,
DeleteAnyCollection = true
}
});
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_Passes(Organization organization, IEnumerable<(OrganizationUserInvite invite, string externalId)> invites,
OrganizationUser invitor,
SutProvider<OrganizationService> sutProvider)
{
// Setup FakeDataProtectorTokenFactory for creating new tokens - this must come first in order to avoid resetting mocks
sutProvider.SetDependency(_orgUserInviteTokenDataFactory, "orgUserInviteTokenDataFactory");
sutProvider.Create();
InviteUser_ArrangeCurrentContextPermissions(organization, sutProvider);
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
SetupOrgUserRepositoryCreateAsyncMock(organizationUserRepository);
await sutProvider.Sut.InviteUsersAsync(organization.Id, invitor.UserId, systemUser: null, invites);
await sutProvider.GetDependency<ISendOrganizationInvitesCommand>().Received(1)
.SendInvitesAsync(Arg.Is<SendInvitesRequest>(info =>
info.Organization == organization &&
info.Users.Length == invites.SelectMany(x => x.invite.Emails).Distinct().Count()));
await sutProvider.GetDependency<IEventService>().Received(1).LogOrganizationUserEventsAsync(Arg.Any<IEnumerable<(OrganizationUser, EventType, DateTime?)>>());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.User,
InvitorUserType = OrganizationUserType.Custom
), OrganizationCustomize, BitAutoData]
public async Task InviteUsers_WithEventSystemUser_Passes(Organization organization, EventSystemUser eventSystemUser, IEnumerable<(OrganizationUserInvite invite, string externalId)> invites,
OrganizationUser invitor,
SutProvider<OrganizationService> sutProvider)
{
// Setup FakeDataProtectorTokenFactory for creating new tokens - this must come first in order to avoid resetting mocks
sutProvider.SetDependency(_orgUserInviteTokenDataFactory, "orgUserInviteTokenDataFactory");
sutProvider.Create();
invitor.Permissions = JsonSerializer.Serialize(new Permissions() { ManageUsers = true },
new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
});
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
var currentContext = sutProvider.GetDependency<ICurrentContext>();
organizationRepository.GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IHasConfirmedOwnersExceptQuery>()
.HasConfirmedOwnersExceptAsync(organization.Id, Arg.Any<IEnumerable<Guid>>())
.Returns(true);
SetupOrgUserRepositoryCreateAsyncMock(organizationUserRepository);
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
currentContext.ManageUsers(organization.Id).Returns(true);
await sutProvider.Sut.InviteUsersAsync(organization.Id, invitingUserId: null, eventSystemUser, invites);
await sutProvider.GetDependency<ISendOrganizationInvitesCommand>().Received(1)
.SendInvitesAsync(Arg.Is<SendInvitesRequest>(info =>
info.Users.Length == invites.SelectMany(i => i.invite.Emails).Count() &&
info.Organization == organization));
await sutProvider.GetDependency<IEventService>().Received(1).LogOrganizationUserEventsAsync(Arg.Any<IEnumerable<(OrganizationUser, EventType, EventSystemUser, DateTime?)>>());
}
[Theory, BitAutoData, OrganizationCustomize, OrganizationInviteCustomize]
public async Task InviteUsers_WithSecretsManager_Passes(Organization organization,
IEnumerable<(OrganizationUserInvite invite, string externalId)> invites,
OrganizationUser savingUser, SutProvider<OrganizationService> sutProvider)
{
organization.PlanType = PlanType.EnterpriseAnnually;
InviteUserHelper_ArrangeValidPermissions(organization, savingUser, sutProvider);
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
// Set up some invites to grant access to SM
invites.First().invite.AccessSecretsManager = true;
var invitedSmUsers = invites.First().invite.Emails.Count();
foreach (var (invite, externalId) in invites.Skip(1))
{
invite.AccessSecretsManager = false;
}
// Assume we need to add seats for all invited SM users
sutProvider.GetDependency<ICountNewSmSeatsRequiredQuery>()
.CountNewSmSeatsRequiredAsync(organization.Id, invitedSmUsers).Returns(invitedSmUsers);
var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
SetupOrgUserRepositoryCreateManyAsyncMock(organizationUserRepository);
SetupOrgUserRepositoryCreateAsyncMock(organizationUserRepository);
sutProvider.GetDependency<IPricingClient>().GetPlanOrThrow(organization.PlanType).Returns(MockPlans.Get(organization.PlanType));
await sutProvider.Sut.InviteUsersAsync(organization.Id, savingUser.Id, systemUser: null, invites);
await sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>().Received(1)
.UpdateSubscriptionAsync(Arg.Is<SecretsManagerSubscriptionUpdate>(update =>
update.SmSeats == organization.SmSeats + invitedSmUsers &&
!update.SmServiceAccountsChanged &&
!update.MaxAutoscaleSmSeatsChanged &&
!update.MaxAutoscaleSmSeatsChanged));
}
[Theory, BitAutoData, OrganizationCustomize, OrganizationInviteCustomize]
public async Task InviteUsers_WithSecretsManager_WhenErrorIsThrown_RevertsAutoscaling(Organization organization,
IEnumerable<(OrganizationUserInvite invite, string externalId)> invites,
OrganizationUser savingUser, SutProvider<OrganizationService> sutProvider)
{
var initialSmSeats = organization.SmSeats;
InviteUserHelper_ArrangeValidPermissions(organization, savingUser, sutProvider);
// Set up some invites to grant access to SM
invites.First().invite.AccessSecretsManager = true;
var invitedSmUsers = invites.First().invite.Emails.Count();
foreach (var (invite, externalId) in invites.Skip(1))
{
invite.AccessSecretsManager = false;
}
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
// Assume we need to add seats for all invited SM users
sutProvider.GetDependency<ICountNewSmSeatsRequiredQuery>()
.CountNewSmSeatsRequiredAsync(organization.Id, invitedSmUsers).Returns(invitedSmUsers);
// Mock SecretsManagerSubscriptionUpdateCommand to actually change the organization's subscription in memory
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>()
.UpdateSubscriptionAsync(Arg.Any<SecretsManagerSubscriptionUpdate>())
.ReturnsForAnyArgs(Task.FromResult(0)).AndDoes(x => organization.SmSeats += invitedSmUsers);
sutProvider.GetDependency<ISendOrganizationInvitesCommand>()
.SendInvitesAsync(Arg.Any<SendInvitesRequest>()).ThrowsAsync<Exception>();
sutProvider.GetDependency<IPricingClient>().GetPlanOrThrow(organization.PlanType)
.Returns(MockPlans.Get(organization.PlanType));
await Assert.ThrowsAsync<AggregateException>(async () =>
await sutProvider.Sut.InviteUsersAsync(organization.Id, savingUser.Id, systemUser: null, invites));
// OrgUser is reverted
// Note: we don't know what their guids are so comparing length is the best we can do
var invitedEmails = invites.SelectMany(i => i.invite.Emails);
await sutProvider.GetDependency<IOrganizationUserRepository>().Received(1).DeleteManyAsync(
Arg.Is<IEnumerable<Guid>>(ids => ids.Count() == invitedEmails.Count()));
Received.InOrder(() =>
{
// Initial autoscaling
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>()
.UpdateSubscriptionAsync(Arg.Is<SecretsManagerSubscriptionUpdate>(update =>
update.SmSeats == initialSmSeats + invitedSmUsers &&
!update.SmServiceAccountsChanged &&
!update.MaxAutoscaleSmSeatsChanged &&
!update.MaxAutoscaleSmSeatsChanged));
// Revert autoscaling
sutProvider.GetDependency<IUpdateSecretsManagerSubscriptionCommand>()
.UpdateSubscriptionAsync(Arg.Is<SecretsManagerSubscriptionUpdate>(update =>
update.SmSeats == initialSmSeats &&
!update.SmServiceAccountsChanged &&
!update.MaxAutoscaleSmSeatsChanged &&
!update.MaxAutoscaleSmSeatsChanged));
});
}
private void InviteUserHelper_ArrangeValidPermissions(Organization organization, OrganizationUser savingUser,
SutProvider<OrganizationService> sutProvider)
{
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<ICurrentContext>().OrganizationOwner(organization.Id).Returns(true);
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
}
[Theory]
[PaidOrganizationCustomize(CheckedPlanType = PlanType.EnterpriseAnnually)]
[BitAutoData("Cannot set max seat autoscaling below seat count", 1, 0, 2, 2)]
[BitAutoData("Cannot set max seat autoscaling below seat count", 4, -1, 6, 6)]
public async Task Enterprise_UpdateMaxSeatAutoscaling_BadInputThrows(string expectedMessage,
int? maxAutoscaleSeats, int seatAdjustment, int? currentSeats, int? currentMaxAutoscaleSeats,
Organization organization, SutProvider<OrganizationService> sutProvider)
=> await UpdateSubscription_BadInputThrows(expectedMessage, maxAutoscaleSeats, seatAdjustment, currentSeats,
currentMaxAutoscaleSeats, organization, sutProvider);
[Theory]
[FreeOrganizationCustomize]
[BitAutoData("Your plan does not allow seat autoscaling", 10, 0, null, null)]
public async Task Free_UpdateMaxSeatAutoscaling_BadInputThrows(string expectedMessage,
int? maxAutoscaleSeats, int seatAdjustment, int? currentSeats, int? currentMaxAutoscaleSeats,
Organization organization, SutProvider<OrganizationService> sutProvider)
=> await UpdateSubscription_BadInputThrows(expectedMessage, maxAutoscaleSeats, seatAdjustment, currentSeats,
currentMaxAutoscaleSeats, organization, sutProvider);
private async Task UpdateSubscription_BadInputThrows(string expectedMessage,
int? maxAutoscaleSeats, int seatAdjustment, int? currentSeats, int? currentMaxAutoscaleSeats,
Organization organization, SutProvider<OrganizationService> sutProvider)
{
organization.Seats = currentSeats;
organization.MaxAutoscaleSeats = currentMaxAutoscaleSeats;
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
sutProvider.GetDependency<IPricingClient>().GetPlanOrThrow(organization.PlanType)
.Returns(MockPlans.Get(organization.PlanType));
var exception = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscription(organization.Id,
seatAdjustment, maxAutoscaleSeats));
Assert.Contains(expectedMessage, exception.Message);
}
[Theory, BitAutoData]
public async Task UpdateSubscription_NoOrganization_Throws(Guid organizationId, SutProvider<OrganizationService> sutProvider)
{
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organizationId).Returns((Organization)null);
await Assert.ThrowsAsync<NotFoundException>(() => sutProvider.Sut.UpdateSubscription(organizationId, 0, null));
}
[Theory, SecretsManagerOrganizationCustomize]
[BitAutoData("You cannot have more Secrets Manager seats than Password Manager seats.", -1)]
public async Task UpdateSubscription_PmSeatAdjustmentLessThanSmSeats_Throws(string expectedMessage,
int seatAdjustment, Organization organization, SutProvider<OrganizationService> sutProvider)
{
organization.Seats = 100;
organization.SmSeats = 100;
sutProvider.GetDependency<IPricingClient>().GetPlanOrThrow(organization.PlanType)
.Returns(MockPlans.Get(organization.PlanType));
sutProvider.GetDependency<IOrganizationRepository>()
.GetOccupiedSeatCountByOrganizationIdAsync(organization.Id).Returns(new OrganizationSeatCounts
{
Sponsored = 0,
Users = 1
});
sutProvider.GetDependency<IOrganizationRepository>().GetByIdAsync(organization.Id).Returns(organization);
var actual = await Assert.ThrowsAsync<BadRequestException>(() => sutProvider.Sut.UpdateSubscription(organization.Id, seatAdjustment, null));
Assert.Contains(expectedMessage, actual.Message);
}
[Theory, PaidOrganizationCustomize]
[BitAutoData(0, 100, null, true, "")]
[BitAutoData(0, 100, 100, true, "")]
[BitAutoData(0, null, 100, true, "")]
[BitAutoData(1, 100, null, true, "")]
[BitAutoData(1, 100, 100, false, "Seat limit has been reached")]
public async Task CanScaleAsync(int seatsToAdd, int? currentSeats, int? maxAutoscaleSeats,
bool expectedResult, string expectedFailureMessage, Organization organization,
SutProvider<OrganizationService> sutProvider)
{
organization.Seats = currentSeats;
organization.MaxAutoscaleSeats = maxAutoscaleSeats;
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
sutProvider.GetDependency<IProviderRepository>().GetByOrganizationIdAsync(organization.Id).ReturnsNull();
var (result, failureMessage) = await sutProvider.Sut.CanScaleAsync(organization, seatsToAdd);
if (expectedFailureMessage == string.Empty)
{
Assert.Empty(failureMessage);
}
else
{
Assert.Contains(expectedFailureMessage, failureMessage);
}
Assert.Equal(expectedResult, result);
}
[Theory, PaidOrganizationCustomize, BitAutoData]
public async Task CanScaleAsync_FailsOnSelfHosted(Organization organization,
SutProvider<OrganizationService> sutProvider)
{
sutProvider.GetDependency<IGlobalSettings>().SelfHosted.Returns(true);
var (result, failureMessage) = await sutProvider.Sut.CanScaleAsync(organization, 10);
Assert.False(result);
Assert.Contains("Cannot autoscale on self-hosted instance", failureMessage);
}
[Theory, PaidOrganizationCustomize, BitAutoData]
public async Task CanScaleAsync_FailsOnResellerManagedOrganization(
Organization organization,
SutProvider<OrganizationService> sutProvider)
{
var provider = new Provider
{
Enabled = true,
Type = ProviderType.Reseller
};
sutProvider.GetDependency<IProviderRepository>().GetByOrganizationIdAsync(organization.Id).Returns(provider);
var (result, failureMessage) = await sutProvider.Sut.CanScaleAsync(organization, 10);
Assert.False(result);
Assert.Contains("Seat limit has been reached. Contact your provider to purchase additional seats.", failureMessage);
}
[Theory]
[BitAutoData(PlanType.TeamsAnnually)]
[BitAutoData(PlanType.TeamsMonthly)]
[BitAutoData(PlanType.TeamsStarter)]
[BitAutoData(PlanType.EnterpriseAnnually)]
[BitAutoData(PlanType.EnterpriseMonthly)]
public void ValidateSecretsManagerPlan_ThrowsException_WhenNoSecretsManagerSeats(PlanType planType, SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = 0,
AdditionalServiceAccounts = 5,
AdditionalSeats = 2
};
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
Assert.Contains("You do not have any Secrets Manager seats!", exception.Message);
}
[Theory]
[BitAutoData(PlanType.Free)]
public void ValidateSecretsManagerPlan_ThrowsException_WhenSubtractingSeats(PlanType planType, SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = -1,
AdditionalServiceAccounts = 5
};
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
Assert.Contains("You can't subtract Secrets Manager seats!", exception.Message);
}
[Theory]
[BitAutoData(PlanType.Free)]
public void ValidateSecretsManagerPlan_ThrowsException_WhenPlanDoesNotAllowAdditionalServiceAccounts(
PlanType planType,
SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = 2,
AdditionalServiceAccounts = 5,
AdditionalSeats = 3
};
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
Assert.Contains("Plan does not allow additional Machine Accounts.", exception.Message);
}
[Theory]
[BitAutoData(PlanType.TeamsAnnually)]
[BitAutoData(PlanType.TeamsMonthly)]
[BitAutoData(PlanType.EnterpriseAnnually)]
[BitAutoData(PlanType.EnterpriseMonthly)]
public void ValidateSecretsManagerPlan_ThrowsException_WhenMoreSeatsThanPasswordManagerSeats(PlanType planType, SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = 4,
AdditionalServiceAccounts = 5,
AdditionalSeats = 3
};
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
Assert.Contains("You cannot have more Secrets Manager seats than Password Manager seats.", exception.Message);
}
[Theory]
[BitAutoData(PlanType.TeamsAnnually)]
[BitAutoData(PlanType.TeamsMonthly)]
[BitAutoData(PlanType.TeamsStarter)]
[BitAutoData(PlanType.EnterpriseAnnually)]
[BitAutoData(PlanType.EnterpriseMonthly)]
public void ValidateSecretsManagerPlan_ThrowsException_WhenSubtractingServiceAccounts(
PlanType planType,
SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = 4,
AdditionalServiceAccounts = -5,
AdditionalSeats = 5
};
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
Assert.Contains("You can't subtract Machine Accounts!", exception.Message);
}
[Theory]
[BitAutoData(PlanType.Free)]
public void ValidateSecretsManagerPlan_ThrowsException_WhenPlanDoesNotAllowAdditionalUsers(
PlanType planType,
SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = 2,
AdditionalServiceAccounts = 0,
AdditionalSeats = 5
};
var exception = Assert.Throws<BadRequestException>(() => sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup));
Assert.Contains("Plan does not allow additional users.", exception.Message);
}
[Theory]
[BitAutoData(PlanType.TeamsAnnually)]
[BitAutoData(PlanType.TeamsMonthly)]
[BitAutoData(PlanType.TeamsStarter)]
[BitAutoData(PlanType.EnterpriseAnnually)]
[BitAutoData(PlanType.EnterpriseMonthly)]
public void ValidateSecretsManagerPlan_ValidPlan_NoExceptionThrown(
PlanType planType,
SutProvider<OrganizationService> sutProvider)
{
var plan = MockPlans.Get(planType);
var signup = new OrganizationUpgrade
{
UseSecretsManager = true,
AdditionalSmSeats = 2,
AdditionalServiceAccounts = 0,
AdditionalSeats = 4
};
sutProvider.Sut.ValidateSecretsManagerPlan(plan, signup);
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Custom,
InvitorUserType = OrganizationUserType.Custom
), BitAutoData]
public async Task ValidateOrganizationUserUpdatePermissions_WithCustomPermission_WhenSavingUserHasCustomPermission_Passes(
CurrentContextOrganization organization,
OrganizationUserInvite organizationUserInvite,
SutProvider<OrganizationService> sutProvider)
{
var invitePermissions = new Permissions { AccessReports = true };
sutProvider.GetDependency<ICurrentContext>().GetOrganization(organization.Id).Returns(organization);
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organization.Id).Returns(true);
sutProvider.GetDependency<ICurrentContext>().AccessReports(organization.Id).Returns(true);
await sutProvider.Sut.ValidateOrganizationUserUpdatePermissions(organization.Id, organizationUserInvite.Type.Value, null, invitePermissions);
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Owner,
InvitorUserType = OrganizationUserType.Admin
), BitAutoData]
public async Task ValidateOrganizationUserUpdatePermissions_WithAdminAddingOwner_Throws(
Guid organizationId,
OrganizationUserInvite organizationUserInvite,
SutProvider<OrganizationService> sutProvider)
{
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.ValidateOrganizationUserUpdatePermissions(organizationId, organizationUserInvite.Type.Value, null, organizationUserInvite.Permissions));
Assert.Contains("only an owner can configure another owner's account.", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Admin,
InvitorUserType = OrganizationUserType.Owner
), BitAutoData]
public async Task ValidateOrganizationUserUpdatePermissions_WithoutManageUsersPermission_Throws(
Guid organizationId,
OrganizationUserInvite organizationUserInvite,
SutProvider<OrganizationService> sutProvider)
{
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.ValidateOrganizationUserUpdatePermissions(organizationId, organizationUserInvite.Type.Value, null, organizationUserInvite.Permissions));
Assert.Contains("your account does not have permission to manage users.", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Admin,
InvitorUserType = OrganizationUserType.Custom
), BitAutoData]
public async Task ValidateOrganizationUserUpdatePermissions_WithCustomAddingAdmin_Throws(
Guid organizationId,
OrganizationUserInvite organizationUserInvite,
SutProvider<OrganizationService> sutProvider)
{
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organizationId).Returns(true);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.ValidateOrganizationUserUpdatePermissions(organizationId, organizationUserInvite.Type.Value, null, organizationUserInvite.Permissions));
Assert.Contains("custom users can not manage admins or owners.", exception.Message.ToLowerInvariant());
}
[Theory]
[OrganizationInviteCustomize(
InviteeUserType = OrganizationUserType.Custom,
InvitorUserType = OrganizationUserType.Custom
), BitAutoData]
public async Task ValidateOrganizationUserUpdatePermissions_WithCustomAddingUser_WithoutPermissions_Throws(
Guid organizationId,
OrganizationUserInvite organizationUserInvite,
SutProvider<OrganizationService> sutProvider)
{
var invitePermissions = new Permissions { AccessReports = true };
sutProvider.GetDependency<ICurrentContext>().ManageUsers(organizationId).Returns(true);
sutProvider.GetDependency<ICurrentContext>().AccessReports(organizationId).Returns(false);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.ValidateOrganizationUserUpdatePermissions(organizationId, organizationUserInvite.Type.Value, null, invitePermissions));
Assert.Contains("custom users can only grant the same custom permissions that they have.", exception.Message.ToLowerInvariant());
}
[Theory]
[BitAutoData(OrganizationUserType.Owner)]
[BitAutoData(OrganizationUserType.Admin)]
[BitAutoData(OrganizationUserType.User)]
public async Task ValidateOrganizationCustomPermissionsEnabledAsync_WithNotCustomType_IsValid(
OrganizationUserType newType,
Guid organizationId,
SutProvider<OrganizationService> sutProvider)
{
await sutProvider.Sut.ValidateOrganizationCustomPermissionsEnabledAsync(organizationId, newType);
}
[Theory, BitAutoData]
public async Task ValidateOrganizationCustomPermissionsEnabledAsync_NotExistingOrg_ThrowsNotFound(
Guid organizationId,
SutProvider<OrganizationService> sutProvider)
{
await Assert.ThrowsAsync<NotFoundException>(() => sutProvider.Sut.ValidateOrganizationCustomPermissionsEnabledAsync(organizationId, OrganizationUserType.Custom));
}
[Theory, BitAutoData]
public async Task ValidateOrganizationCustomPermissionsEnabledAsync_WithUseCustomPermissionsDisabled_ThrowsBadRequest(
Organization organization,
SutProvider<OrganizationService> sutProvider)
{
organization.UseCustomPermissions = false;
sutProvider.GetDependency<IOrganizationRepository>()
.GetByIdAsync(organization.Id)
.Returns(organization);
var exception = await Assert.ThrowsAsync<BadRequestException>(
() => sutProvider.Sut.ValidateOrganizationCustomPermissionsEnabledAsync(organization.Id, OrganizationUserType.Custom));
Assert.Contains("to enable custom permissions", exception.Message.ToLowerInvariant());
}
[Theory, BitAutoData]
public async Task ValidateOrganizationCustomPermissionsEnabledAsync_WithUseCustomPermissionsEnabled_IsValid(
Organization organization,
SutProvider<OrganizationService> sutProvider)
{
organization.UseCustomPermissions = true;
sutProvider.GetDependency<IOrganizationRepository>()
.GetByIdAsync(organization.Id)
.Returns(organization);
await sutProvider.Sut.ValidateOrganizationCustomPermissionsEnabledAsync(organization.Id, OrganizationUserType.Custom);
}
[Theory, BitAutoData]
public async Task UpdateAsync_WhenValidOrganization_AndUpdateBillingIsTrue_UpdateStripeCustomerAndOrganization(Organization organization, SutProvider<OrganizationService> sutProvider)
{
// Arrange
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var applicationCacheService = sutProvider.GetDependency<IApplicationCacheService>();
var stripeAdapter = sutProvider.GetDependency<IStripeAdapter>();
var eventService = sutProvider.GetDependency<IEventService>();
var requestOptionsReturned = new CustomerUpdateOptions
{
Email = organization.BillingEmail,
Description = organization.DisplayBusinessName(),
InvoiceSettings = new CustomerInvoiceSettingsOptions
{
// This overwrites the existing custom fields for this organization
CustomFields =
[
new CustomerInvoiceSettingsCustomFieldOptions
{
Name = organization.SubscriberType(),
Value = organization.DisplayName()[..30]
}
]
},
};
organizationRepository
.GetByIdentifierAsync(organization.Identifier!)
.Returns(organization);
// Act
await sutProvider.Sut.UpdateAsync(organization, updateBilling: true);
// Assert
await organizationRepository
.Received(1)
.GetByIdentifierAsync(Arg.Is<string>(id => id == organization.Identifier));
await stripeAdapter
.Received(1)
.CustomerUpdateAsync(
Arg.Is<string>(id => id == organization.GatewayCustomerId),
Arg.Is<CustomerUpdateOptions>(options => options.Email == requestOptionsReturned.Email
&& options.Description == requestOptionsReturned.Description
&& options.InvoiceSettings.CustomFields.First().Name == requestOptionsReturned.InvoiceSettings.CustomFields.First().Name
&& options.InvoiceSettings.CustomFields.First().Value == requestOptionsReturned.InvoiceSettings.CustomFields.First().Value)); ;
await organizationRepository
.Received(1)
.ReplaceAsync(Arg.Is<Organization>(org => org == organization));
await applicationCacheService
.Received(1)
.UpsertOrganizationAbilityAsync(Arg.Is<Organization>(org => org == organization));
await eventService
.Received(1)
.LogOrganizationEventAsync(Arg.Is<Organization>(org => org == organization),
Arg.Is<EventType>(e => e == EventType.Organization_Updated));
}
[Theory, BitAutoData]
public async Task UpdateAsync_WhenValidOrganization_AndUpdateBillingIsFalse_UpdateOrganization(Organization organization, SutProvider<OrganizationService> sutProvider)
{
// Arrange
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var applicationCacheService = sutProvider.GetDependency<IApplicationCacheService>();
var stripeAdapter = sutProvider.GetDependency<IStripeAdapter>();
var eventService = sutProvider.GetDependency<IEventService>();
organizationRepository
.GetByIdentifierAsync(organization.Identifier!)
.Returns(organization);
// Act
await sutProvider.Sut.UpdateAsync(organization, updateBilling: false);
// Assert
await organizationRepository
.Received(1)
.GetByIdentifierAsync(Arg.Is<string>(id => id == organization.Identifier));
await stripeAdapter
.DidNotReceiveWithAnyArgs()
.CustomerUpdateAsync(Arg.Any<string>(), Arg.Any<CustomerUpdateOptions>());
await organizationRepository
.Received(1)
.ReplaceAsync(Arg.Is<Organization>(org => org == organization));
await applicationCacheService
.Received(1)
.UpsertOrganizationAbilityAsync(Arg.Is<Organization>(org => org == organization));
await eventService
.Received(1)
.LogOrganizationEventAsync(Arg.Is<Organization>(org => org == organization),
Arg.Is<EventType>(e => e == EventType.Organization_Updated));
}
[Theory, BitAutoData]
public async Task UpdateAsync_WhenOrganizationHasNoId_ThrowsApplicationException(Organization organization, SutProvider<OrganizationService> sutProvider)
{
// Arrange
organization.Id = Guid.Empty;
// Act/Assert
var exception = await Assert.ThrowsAnyAsync<ApplicationException>(() => sutProvider.Sut.UpdateAsync(organization));
Assert.Equal("Cannot create org this way. Call SignUpAsync.", exception.Message);
}
[Theory, BitAutoData]
public async Task UpdateAsync_WhenIdentifierAlreadyExistsForADifferentOrganization_ThrowsBadRequestException(Organization organization, SutProvider<OrganizationService> sutProvider)
{
// Arrange
var organizationRepository = sutProvider.GetDependency<IOrganizationRepository>();
var differentOrganization = new Organization { Id = Guid.NewGuid() };
organizationRepository
.GetByIdentifierAsync(organization.Identifier!)
.Returns(differentOrganization);
// Act/Assert
var exception = await Assert.ThrowsAnyAsync<BadRequestException>(() => sutProvider.Sut.UpdateAsync(organization));
Assert.Equal("Identifier already in use by another organization.", exception.Message);
await organizationRepository
.Received(1)
.GetByIdentifierAsync(Arg.Is<string>(id => id == organization.Identifier));
}
[Theory]
[BitAutoData(false, true, false, true)]
[BitAutoData(true, false, true, false)]
public async Task UpdateCollectionManagementSettingsAsync_WhenSettingsChanged_LogsSpecificEvents(
bool newLimitCollectionCreation,
bool newLimitCollectionDeletion,
bool newLimitItemDeletion,
bool newAllowAdminAccessToAllCollectionItems,
Organization existingOrganization, SutProvider<OrganizationService> sutProvider)
{
// Arrange
existingOrganization.LimitCollectionCreation = false;
existingOrganization.LimitCollectionDeletion = false;
existingOrganization.LimitItemDeletion = false;
existingOrganization.AllowAdminAccessToAllCollectionItems = false;
sutProvider.GetDependency<IOrganizationRepository>()
.GetByIdAsync(existingOrganization.Id)
.Returns(existingOrganization);
var settings = new OrganizationCollectionManagementSettings
{
LimitCollectionCreation = newLimitCollectionCreation,
LimitCollectionDeletion = newLimitCollectionDeletion,
LimitItemDeletion = newLimitItemDeletion,
AllowAdminAccessToAllCollectionItems = newAllowAdminAccessToAllCollectionItems
};
// Act
await sutProvider.Sut.UpdateCollectionManagementSettingsAsync(existingOrganization.Id, settings);
// Assert
var eventService = sutProvider.GetDependency<IEventService>();
if (newLimitCollectionCreation)
{
await eventService.Received(1).LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_LimitCollectionCreationEnabled));
}
else
{
await eventService.DidNotReceive().LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_LimitCollectionCreationEnabled));
}
if (newLimitCollectionDeletion)
{
await eventService.Received(1).LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_LimitCollectionDeletionEnabled));
}
else
{
await eventService.DidNotReceive().LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_LimitCollectionDeletionEnabled));
}
if (newLimitItemDeletion)
{
await eventService.Received(1).LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_LimitItemDeletionEnabled));
}
else
{
await eventService.DidNotReceive().LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_LimitItemDeletionEnabled));
}
if (newAllowAdminAccessToAllCollectionItems)
{
await eventService.Received(1).LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_AllowAdminAccessToAllCollectionItemsEnabled));
}
else
{
await eventService.DidNotReceive().LogOrganizationEventAsync(
Arg.Is<Organization>(org => org.Id == existingOrganization.Id),
Arg.Is<EventType>(e => e == EventType.Organization_CollectionManagement_AllowAdminAccessToAllCollectionItemsEnabled));
}
}
[Theory, BitAutoData]
public async Task UpdateCollectionManagementSettingsAsync_WhenOrganizationNotFound_ThrowsNotFoundException(
Guid organizationId, OrganizationCollectionManagementSettings settings, SutProvider<OrganizationService> sutProvider)
{
// Arrange
sutProvider.GetDependency<IOrganizationRepository>()
.GetByIdAsync(organizationId)
.Returns((Organization)null);
// Act/Assert
await Assert.ThrowsAsync<NotFoundException>(() => sutProvider.Sut.UpdateCollectionManagementSettingsAsync(organizationId, settings));
await sutProvider.GetDependency<IOrganizationRepository>()
.Received(1)
.GetByIdAsync(organizationId);
}
// Must set real guids in order for dictionary of guids to not throw aggregate exceptions
private void SetupOrgUserRepositoryCreateManyAsyncMock(IOrganizationUserRepository organizationUserRepository)
{
organizationUserRepository.CreateManyAsync(Arg.Any<IEnumerable<OrganizationUser>>()).Returns(
info =>
{
var orgUsers = info.Arg<IEnumerable<OrganizationUser>>();
foreach (var orgUser in orgUsers)
{
orgUser.Id = Guid.NewGuid();
}
return Task.FromResult<ICollection<Guid>>(orgUsers.Select(u => u.Id).ToList());
}
);
organizationUserRepository.CreateAsync(Arg.Any<OrganizationUser>(), Arg.Any<IEnumerable<CollectionAccessSelection>>()).Returns(
info =>
{
var orgUser = info.Arg<OrganizationUser>();
orgUser.Id = Guid.NewGuid();
return Task.FromResult<Guid>(orgUser.Id);
}
);
}
// Must set real guids in order for dictionary of guids to not throw aggregate exceptions
private void SetupOrgUserRepositoryCreateAsyncMock(IOrganizationUserRepository organizationUserRepository)
{
organizationUserRepository.CreateAsync(Arg.Any<OrganizationUser>(),
Arg.Any<IEnumerable<CollectionAccessSelection>>()).Returns(
info =>
{
var orgUser = info.Arg<OrganizationUser>();
orgUser.Id = Guid.NewGuid();
return Task.FromResult<Guid>(orgUser.Id);
}
);
}
}
| OrganizationServiceTests |
csharp | mongodb__mongo-csharp-driver | src/MongoDB.Driver/Linq/Linq3Implementation/Ast/Expressions/AstPickAccumulatorOperator.cs | {
"start": 673,
"end": 849
} | internal enum ____
{
Bottom,
BottomN,
FirstN,
LastN,
MaxN,
MinN,
Top,
TopN
}
| AstPickAccumulatorOperator |
csharp | domaindrivendev__Swashbuckle.AspNetCore | test/Swashbuckle.AspNetCore.TestSupport/Fixtures/SelfReferencingType.cs | {
"start": 48,
"end": 138
} | public class ____
{
public SelfReferencingType Another { get; set; }
}
| SelfReferencingType |
csharp | ServiceStack__ServiceStack | ServiceStack.OrmLite/tests/ServiceStack.OrmLite.Tests/Issues/SqlExpressionJoinWithRowversionTests.cs | {
"start": 247,
"end": 447
} | public class ____
{
public int Id { get; set; }
public bool Bool { get; set; }
public string Name { get; set; }
public ulong RowVersion { get; set; }
}
| TableA |
csharp | AvaloniaUI__Avalonia | src/Avalonia.Base/Utilities/SafeEnumerableHashSet.cs | {
"start": 411,
"end": 567
} | class ____'t actually implement <see cref="ISet{T}"/> as it's not
/// currently needed - feel free to add missing methods etc.
/// </remarks>
| doesn |
csharp | icsharpcode__ILSpy | ICSharpCode.Decompiler/TypeSystem/InheritanceHelper.cs | {
"start": 1469,
"end": 1951
} | interface ____? (would allow for easy caching)
#region GetBaseMember
/// <summary>
/// Gets the base member that has the same signature.
/// </summary>
public static IMember? GetBaseMember(IMember member)
{
return GetBaseMembers(member, false).FirstOrDefault();
}
/// <summary>
/// Gets all base members that have the same signature.
/// </summary>
/// <returns>
/// List of base members with the same signature. The member from the derived-most base | itself |
csharp | dotnet__orleans | src/Orleans.Analyzers/Constants.cs | {
"start": 34,
"end": 1075
} | internal static class ____
{
public const string SystemNamespace = "System";
public const string IAddressibleFullyQualifiedName = "Orleans.Runtime.IAddressable";
public const string GrainBaseFullyQualifiedName = "Orleans.Grain";
public const string IdAttributeName = "Id";
public const string IdAttributeFullyQualifiedName = "global::Orleans.IdAttribute";
public const string GenerateSerializerAttributeName = "GenerateSerializer";
public const string GenerateSerializerAttributeFullyQualifiedName = "global::Orleans.GenerateSerializerAttribute";
public const string SerializableAttributeName = "Serializable";
public const string NonSerializedAttribute = "NonSerialized";
public const string NonSerializedAttributeFullyQualifiedName = "global::System.NonSerializedAttribute";
public const string AliasAttributeName = "Alias";
public const string AliasAttributeFullyQualifiedName = "global::Orleans.AliasAttribute";
}
} | Constants |
csharp | dotnetcore__CAP | src/DotNetCore.CAP/Transport/IConsumerClient.cs | {
"start": 515,
"end": 2971
} | public interface ____ : IAsyncDisposable
{
/// <summary>
/// Gets the broker address information that this consumer is connected to
/// </summary>
BrokerAddress BrokerAddress { get; }
/// <summary>
/// Creates (if necessary) and retrieves topic identifiers from the message broker
/// </summary>
/// <param name="topicNames">Names of the requested topics to fetch</param>
/// <returns>A collection of topic identifiers returned by the broker</returns>
Task<ICollection<string>> FetchTopicsAsync(IEnumerable<string> topicNames)
{
return Task.FromResult<ICollection<string>>(topicNames.ToList());
}
/// <summary>
/// Subscribes to a set of topics in the message broker
/// </summary>
/// <param name="topics">Collection of topic identifiers to subscribe to</param>
/// <returns>A task that represents the asynchronous subscribe operation</returns>
Task SubscribeAsync(IEnumerable<string> topics);
/// <summary>
/// Starts listening for messages from the subscribed topics
/// </summary>
/// <param name="timeout">Maximum time to wait when polling for messages</param>
/// <param name="cancellationToken">Token to cancel the listening operation</param>
/// <returns>A task that represents the asynchronous listening operation</returns>
Task ListeningAsync(TimeSpan timeout, CancellationToken cancellationToken);
/// <summary>
/// Manually commits message offset when the message consumption is complete
/// </summary>
/// <param name="sender">The message or context object to commit</param>
/// <returns>A task that represents the asynchronous commit operation</returns>
Task CommitAsync(object? sender);
/// <summary>
/// Rejects the message and optionally returns it to the queue for reprocessing
/// </summary>
/// <param name="sender">The message or context object to reject</param>
/// <returns>A task that represents the asynchronous reject operation</returns>
Task RejectAsync(object? sender);
/// <summary>
/// Callback that is invoked when a message is received from the broker
/// </summary>
public Func<TransportMessage, object?, Task>? OnMessageCallback { get; set; }
/// <summary>
/// Callback that is invoked when logging events occur in the consumer client
/// </summary>
public Action<LogMessageEventArgs>? OnLogCallback { get; set; }
}
| IConsumerClient |
csharp | App-vNext__Polly | src/Polly.Extensions/DependencyInjection/ConfigureResiliencePipelineRegistryOptions.cs | {
"start": 61,
"end": 242
} | internal sealed class ____<TKey>
where TKey : notnull
{
public List<Action<ResiliencePipelineRegistry<TKey>>> Actions { get; } = [];
}
| ConfigureResiliencePipelineRegistryOptions |
csharp | dotnetcore__Util | test/Util.Ui.NgZorro.Tests/Autocompletes/AutocompleteTagHelperTest.Extend.cs | {
"start": 230,
"end": 7764
} | public partial class ____ {
#region 辅助操作
/// <summary>
/// 添加选项
/// </summary>
private void AppendOptions( StringBuilder result ) {
result.Append( "@if(x_id.isGroup){" );
result.Append( "@for(group of x_id.optionGroups;track group.text ){" );
result.Append( "<nz-auto-optgroup [nzLabel]=\"group.text\">" );
result.Append( "@for(item of group.value;track item.value){" );
result.Append( "<nz-auto-option [nzDisabled]=\"item.disabled\" [nzLabel]=\"item.text\" [nzValue]=\"item.value\">" );
result.Append( "{{item.text}}" );
result.Append( "</nz-auto-option>" );
result.Append( "}" );
result.Append( "</nz-auto-optgroup>" );
result.Append( "}} @else {" );
result.Append( "@for(item of x_id.options;track item.value){" );
result.Append( "<nz-auto-option [nzDisabled]=\"item.disabled\" [nzLabel]=\"item.text\" [nzValue]=\"item.value\">" );
result.Append( "{{item.text}}" );
result.Append( "</nz-auto-option>" );
result.Append( "}}" );
}
#endregion
#region EnableExtend
/// <summary>
/// 测试启用扩展指令
/// </summary>
[Fact]
public void TestEnableExtend_1() {
_wrapper.SetContextAttribute( UiConst.EnableExtend, true );
var result = new StringBuilder();
result.Append( "<nz-autocomplete #x_id=\"xSelectExtend\" x-select-extend=\"\">" );
AppendOptions( result );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
/// <summary>
/// 测试启用扩展指令 - 不启用
/// </summary>
[Fact]
public void TestEnableExtend_2() {
_wrapper.SetContextAttribute( UiConst.EnableExtend, false );
var result = new StringBuilder();
result.Append( "<nz-autocomplete>" );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
#region AutoLoad
/// <summary>
/// 测试初始化时是否自动加载数据
/// </summary>
[Fact]
public void TestAutoLoad() {
_wrapper.SetContextAttribute( UiConst.AutoLoad, "false" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete [autoLoad]=\"false\">" );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
#region QueryParam
/// <summary>
/// 测试查询参数
/// </summary>
[Fact]
public void TestQueryParam() {
_wrapper.SetContextAttribute( UiConst.QueryParam, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete [(queryParam)]=\"a\">" );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
#region Sort
/// <summary>
/// 测试排序条件
/// </summary>
[Fact]
public void TestSort() {
_wrapper.SetContextAttribute( UiConst.Sort, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete order=\"a\">" );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
/// <summary>
/// 测试排序条件
/// </summary>
[Fact]
public void TestBindSort() {
_wrapper.SetContextAttribute( AngularConst.BindSort, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete [order]=\"a\">" );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
#region Url
/// <summary>
/// 测试Api地址
/// </summary>
[Fact]
public void TestUrl_1() {
_wrapper.SetContextAttribute( UiConst.Url, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete #x_id=\"xSelectExtend\" url=\"a\" x-select-extend=\"\">" );
AppendOptions( result );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
/// <summary>
/// 测试Api地址
/// </summary>
[Fact]
public void TestBindUrl() {
_wrapper.SetContextAttribute( AngularConst.BindUrl, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete #x_id=\"xSelectExtend\" x-select-extend=\"\" [url]=\"a\">" );
AppendOptions( result );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
#region Data
/// <summary>
/// 测试数据源
/// </summary>
[Fact]
public void TestData() {
_wrapper.SetContextAttribute( UiConst.Data, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete #x_id=\"xSelectExtend\" x-select-extend=\"\" [data]=\"a\">" );
AppendOptions( result );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
/// <summary>
/// 测试数据源 - 多语言
/// </summary>
[Fact]
public void TestData_I18n() {
NgZorroOptionsService.SetOptions( new NgZorroOptions { EnableI18n = true } );
_wrapper.SetContextAttribute( UiConst.Data, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete #x_id=\"xSelectExtend\" x-select-extend=\"\" [data]=\"a\">" );
result.Append( "@if(x_id.isGroup){" );
result.Append( "@for(group of x_id.optionGroups;track group.text ){" );
result.Append( "<nz-auto-optgroup [nzLabel]=\"group.text|i18n\">" );
result.Append( "@for(item of group.value;track item.value){" );
result.Append( "<nz-auto-option [nzDisabled]=\"item.disabled\" [nzLabel]=\"item.text|i18n\" [nzValue]=\"item.value\">" );
result.Append( "{{item.text|i18n}}" );
result.Append( "</nz-auto-option>" );
result.Append( "}" );
result.Append( "</nz-auto-optgroup>" );
result.Append( "}} @else {" );
result.Append( "@for(item of x_id.options;track item.value){" );
result.Append( "<nz-auto-option [nzDisabled]=\"item.disabled\" [nzLabel]=\"item.text|i18n\" [nzValue]=\"item.value\">" );
result.Append( "{{item.text|i18n}}" );
result.Append( "</nz-auto-option>" );
result.Append( "}}" );
result.Append( "</nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
#region OnLoad
/// <summary>
/// 测试数据加载完成事件
/// </summary>
[Fact]
public void TestOnLoad() {
_wrapper.SetContextAttribute( UiConst.OnLoad, "a" );
var result = new StringBuilder();
result.Append( "<nz-autocomplete (onLoad)=\"a\"></nz-autocomplete>" );
Assert.Equal( result.ToString(), GetResult() );
}
#endregion
}
} | AutocompleteTagHelperTest |
csharp | dotnet__orleans | src/api/Orleans.Core/Orleans.Core.cs | {
"start": 109909,
"end": 110630
} | partial class ____ : global::Orleans.Serialization.Cloning.IDeepCopier<global::Orleans.MembershipEntry>, global::Orleans.Serialization.Cloning.IDeepCopier
{
public Copier_MembershipEntry(global::Orleans.Serialization.Serializers.ICodecProvider codecProvider) { }
public global::Orleans.MembershipEntry DeepCopy(global::Orleans.MembershipEntry original, global::Orleans.Serialization.Cloning.CopyContext context) { throw null; }
}
[System.CodeDom.Compiler.GeneratedCode("OrleansCodeGen", "9.0.0.0")]
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
[System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
public sealed | Copier_MembershipEntry |
csharp | dotnet__orleans | test/NonSilo.Tests/Caching/ConcurrentLruSoakTests.cs | {
"start": 673,
"end": 10144
} | public sealed class ____
{
private readonly ITestOutputHelper testOutputHelper;
private const int HotCap = 3;
private const int WarmCap = 3;
private const int ColdCap = 3;
private const int Capacity = HotCap + WarmCap + ColdCap;
private ConcurrentLruCache<int, string> lru = new ConcurrentLruCache<int, string>(Capacity, EqualityComparer<int>.Default);
public ConcurrentLruCacheSoakTests(ITestOutputHelper testOutputHelper)
{
this.testOutputHelper = testOutputHelper;
}
/// <summary>
/// Tests concurrent GetOrAdd operations to ensure the cache maintains consistency under heavy read/write load.
/// Verifies that the cache size remains within bounds and internal structures remain valid.
/// </summary>
[Fact]
public async Task WhenSoakConcurrentGetCacheEndsInConsistentState()
{
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
for (var i = 0; i < 100000; i++)
{
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
// allow +/- 1 variance for capacity
lru.Count.Should().BeInRange(7, 10);
RunIntegrityCheck();
}
}
[Fact]
public async Task WhenSoakConcurrentGetWithArgCacheEndsInConsistentState()
{
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
for (var i = 0; i < 100000; i++)
{
// use the arg overload
lru.GetOrAdd(i + 1, (i, s) => i.ToString(), "Foo");
}
});
testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
// allow +/- 1 variance for capacity
lru.Count.Should().BeInRange(7, 10);
RunIntegrityCheck();
}
}
[Fact]
public async Task WhenSoakConcurrentGetAndRemoveCacheEndsInConsistentState()
{
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
for (var i = 0; i < 100000; i++)
{
lru.TryRemove(i + 1);
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
RunIntegrityCheck();
}
}
[Fact]
public async Task WhenSoakConcurrentGetAndRemoveKvpCacheEndsInConsistentState()
{
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
for (var i = 0; i < 100000; i++)
{
lru.TryRemove(new KeyValuePair<int, string>(i + 1, (i + 1).ToString()));
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
RunIntegrityCheck();
}
}
[Fact]
public async Task WhenSoakConcurrentGetAndUpdateCacheEndsInConsistentState()
{
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
for (var i = 0; i < 100000; i++)
{
lru.TryUpdate(i + 1, i.ToString());
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
RunIntegrityCheck();
}
}
[Fact]
public async Task WhenSoakConcurrentGetAndAddCacheEndsInConsistentState()
{
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
for (var i = 0; i < 100000; i++)
{
lru.AddOrUpdate(i + 1, i.ToString());
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
RunIntegrityCheck();
}
}
[Fact]
public async Task WhenSoakConcurrentGetAndUpdateValueTypeCacheEndsInConsistentState()
{
var lruVT = new ConcurrentLruCache<int, Guid>(Capacity, EqualityComparer<int>.Default);
for (var i = 0; i < 10; i++)
{
await Threaded.Run(4, () =>
{
var b = new byte[8];
for (var i = 0; i < 100000; i++)
{
lruVT.TryUpdate(i + 1, new Guid(i, 0, 0, b));
lruVT.GetOrAdd(i + 1, x => new Guid(x, 0, 0, b));
}
});
testOutputHelper.WriteLine($"{lruVT.HotCount} {lruVT.WarmCount} {lruVT.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lruVT.Keys));
ConcurrentLruCacheIntegrityChecker.Validate(lruVT);
}
}
[Fact]
public async Task WhenAddingCacheSizeItemsNothingIsEvicted()
{
const int size = 1024;
var cache = new ConcurrentLruCache<int, int>(size);
await Threaded.Run(4, () =>
{
for (var i = 0; i < size; i++)
{
cache.GetOrAdd(i, k => k);
}
});
cache.Metrics.Evicted.Should().Be(0);
}
[Fact]
public async Task WhenConcurrentUpdateAndRemoveKvp()
{
var tcs = new TaskCompletionSource<int>();
var removal = Task.Run(() =>
{
while (!tcs.Task.IsCompleted)
{
lru.TryRemove(new KeyValuePair<int, string>(5, "x"));
}
});
for (var i = 0; i < 100_000; i++)
{
lru.AddOrUpdate(5, "a");
lru.TryGet(5, out _).Should().BeTrue("key 'a' should not be deleted");
lru.AddOrUpdate(5, "x");
}
tcs.SetResult(int.MaxValue);
await removal;
}
[Theory]
[Repeat(10)]
public async Task WhenConcurrentGetAndClearCacheEndsInConsistentState(int iteration)
{
await Threaded.Run(4, r =>
{
for (var i = 0; i < 100000; i++)
{
// clear 6,250 times per 1_000_000 iters
if (r == 0 && (i & 15) == 15)
{
lru.Clear();
}
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{iteration} {lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
RunIntegrityCheck();
}
[Theory]
[Repeat(10)]
public async Task WhenConcurrentGetAndClearDuringWarmupCacheEndsInConsistentState(int iteration)
{
await Threaded.Run(4, r =>
{
for (var i = 0; i < 100000; i++)
{
// clear 25,000 times per 1_000_000 iters
// capacity is 9, so we will try to clear before warmup is done
if (r == 0 && (i & 3) == 3)
{
lru.Clear();
}
lru.GetOrAdd(i + 1, i => i.ToString());
}
});
testOutputHelper.WriteLine($"{iteration} {lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
RunIntegrityCheck();
}
// This test will run forever if there is a live lock.
// Since the cache bookkeeping has some overhead, it is harder to provoke
// spinning inside the reader thread compared to LruItemSoakTests.DetectTornStruct.
[Theory]
[Repeat(10)]
public async Task WhenValueIsBigStructNoLiveLock(int _)
{
using var source = new CancellationTokenSource();
var started = new TaskCompletionSource<bool>();
var cache = new ConcurrentLruCache<int, Guid>(Capacity, EqualityComparer<int>.Default);
var setTask = Task.Run(() => Setter(cache, source.Token, started));
await started.Task;
Checker(cache, source);
await setTask;
}
private void Setter(ConcurrentLruCache<int, Guid> cache, CancellationToken cancelToken, TaskCompletionSource<bool> started)
{
started.SetResult(true);
while (true)
{
cache.AddOrUpdate(1, Guid.NewGuid());
cache.AddOrUpdate(1, Guid.NewGuid());
if (cancelToken.IsCancellationRequested)
{
return;
}
}
}
private void Checker(ConcurrentLruCache<int, Guid> cache, CancellationTokenSource source)
{
for (var count = 0; count < 100_000; ++count)
{
cache.TryGet(1, out _);
}
source.Cancel();
}
private void RunIntegrityCheck() => ConcurrentLruCacheIntegrityChecker.Validate(lru);
| ConcurrentLruCacheSoakTests |
csharp | protobuf-net__protobuf-net | src/protobuf-net.Test/DateTimeOnlyTests.cs | {
"start": 3499,
"end": 3725
} | public class ____
{
[ProtoMember(1)]
public DateOnly[] Dates { get; set; }
[ProtoMember(2)]
public TimeOnly[] Times { get; set; }
}
}
}
#endif | SomeTypeWithArrays |
csharp | dotnet__aspnetcore | src/Servers/Kestrel/Core/src/Internal/HttpConnection.cs | {
"start": 12913,
"end": 13019
} | private enum ____
{
Initializing,
Selected,
Aborted
}
}
| ProtocolSelectionState |
csharp | dotnet__aspire | src/Aspire.Hosting.Testing/Properties/Resources.Designer.cs | {
"start": 1119,
"end": 4805
} | internal class ____ {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Aspire.Hosting.Testing.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to The application must be started before resolving endpoints or connection strings..
/// </summary>
internal static string ApplicationNotStartedExceptionMessage {
get {
return ResourceManager.GetString("ApplicationNotStartedExceptionMessage", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Endpoint '{0}' for resource '{1}' not found..
/// </summary>
internal static string EndpointForResourceNotFoundExceptionMessage {
get {
return ResourceManager.GetString("EndpointForResourceNotFoundExceptionMessage", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Resource '{0}' does not expose a connection string..
/// </summary>
internal static string ResourceDoesNotExposeConnectionStringExceptionMessage {
get {
return ResourceManager.GetString("ResourceDoesNotExposeConnectionStringExceptionMessage", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Resource '{0}' has no allocated endpoints..
/// </summary>
internal static string ResourceHasNoAllocatedEndpointsExceptionMessage {
get {
return ResourceManager.GetString("ResourceHasNoAllocatedEndpointsExceptionMessage", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Resource '{0}' not found..
/// </summary>
internal static string ResourceNotFoundExceptionMessage {
get {
return ResourceManager.GetString("ResourceNotFoundExceptionMessage", resourceCulture);
}
}
}
}
| Resources |
csharp | microsoft__FASTER | cs/test/ReadAddressTests.cs | {
"start": 279,
"end": 591
} | internal class ____
{
const int numKeys = 1000;
const int keyMod = 100;
const int maxLap = numKeys / keyMod;
const int deleteLap = maxLap / 2;
const int defaultKeyToScan = 42;
private static int LapOffset(int lap) => lap * numKeys * 100;
| ReadAddressTests |
csharp | dotnet__maui | src/Core/src/Graphics/PaintExtensions.iOS.cs | {
"start": 178,
"end": 5598
} | partial class ____
{
public static CALayer? ToCALayer(this Paint paint, CGRect frame = default)
{
if (paint is SolidPaint solidPaint)
return solidPaint.CreateCALayer(frame);
if (paint is LinearGradientPaint linearGradientPaint)
return linearGradientPaint.CreateCALayer(frame);
if (paint is RadialGradientPaint radialGradientPaint)
return radialGradientPaint.CreateCALayer(frame);
if (paint is ImagePaint imagePaint)
return imagePaint.CreateCALayer(frame);
if (paint is PatternPaint patternPaint)
return patternPaint.CreateCALayer(frame);
return null;
}
public static CALayer? CreateCALayer(this SolidPaint solidPaint, CGRect frame = default)
{
var solidColorLayer = new StaticCALayer
{
ContentsGravity = CALayer.GravityResizeAspectFill,
Frame = frame,
BackgroundColor = solidPaint.Color.ToCGColor()
};
return solidColorLayer;
}
public static CALayer? CreateCALayer(this GradientPaint gradientPaint, CGRect frame = default)
{
if (gradientPaint is LinearGradientPaint linearGradientPaint)
return linearGradientPaint.CreateCALayer(frame);
if (gradientPaint is RadialGradientPaint radialGradientPaint)
return radialGradientPaint.CreateCALayer(frame);
return null;
}
public static CALayer? CreateCALayer(this LinearGradientPaint linearGradientPaint, CGRect frame = default)
{
var p1 = linearGradientPaint.StartPoint;
var p2 = linearGradientPaint.EndPoint;
var linearGradientLayer = new StaticCAGradientLayer
{
ContentsGravity = CALayer.GravityResizeAspectFill,
Frame = frame,
LayerType = CAGradientLayerType.Axial,
StartPoint = new CGPoint(p1.X, p1.Y),
EndPoint = new CGPoint(p2.X, p2.Y)
};
if (linearGradientPaint.GradientStops != null && linearGradientPaint.GradientStops.Length > 0)
{
var orderedStops = linearGradientPaint.GradientStops.OrderBy(x => x.Offset).ToList();
linearGradientLayer.Colors = GetCAGradientLayerColors(orderedStops);
linearGradientLayer.Locations = GetCAGradientLayerLocations(orderedStops);
}
return linearGradientLayer;
}
public static CALayer? CreateCALayer(this RadialGradientPaint radialGradientPaint, CGRect frame = default)
{
var center = radialGradientPaint.Center;
var radius = radialGradientPaint.Radius;
var radialGradientLayer = new StaticCAGradientLayer
{
ContentsGravity = CALayer.GravityResizeAspectFill,
Frame = frame,
#pragma warning disable CA1416 // TODO: 'CAGradientLayerType.Radial' is only supported on: 'ios' 12.0 and later
LayerType = CAGradientLayerType.Radial,
#pragma warning restore CA1416
StartPoint = new CGPoint(center.X, center.Y),
EndPoint = GetRadialGradientPaintEndPoint(center, radius),
CornerRadius = (float)radius
};
if (radialGradientPaint.GradientStops != null && radialGradientPaint.GradientStops.Length > 0)
{
var orderedStops = radialGradientPaint.GradientStops.OrderBy(x => x.Offset).ToList();
radialGradientLayer.Colors = GetCAGradientLayerColors(orderedStops);
radialGradientLayer.Locations = GetCAGradientLayerLocations(orderedStops);
}
return radialGradientLayer;
}
public static CALayer? CreateCALayer(this ImagePaint imagePaint, CGRect frame = default)
{
throw new NotImplementedException();
}
public static CALayer? CreateCALayer(this PatternPaint patternPaint, CGRect frame = default)
{
throw new NotImplementedException();
}
static CGPoint GetRadialGradientPaintEndPoint(Point startPoint, double radius)
{
double x = startPoint.X == 1 ? (startPoint.X - radius) : (startPoint.X + radius);
if (x < 0)
x = 0;
if (x > 1)
x = 1;
double y = startPoint.Y == 1 ? (startPoint.Y - radius) : (startPoint.Y + radius);
if (y < 0)
y = 0;
if (y > 1)
y = 1;
return new CGPoint(x, y);
}
static NSNumber[] GetCAGradientLayerLocations(List<PaintGradientStop> gradientStops)
{
if (gradientStops == null || gradientStops.Count == 0)
return Array.Empty<NSNumber>();
if (gradientStops.Count > 1 && gradientStops.Any(gt => gt.Offset != 0))
return gradientStops.Select(x => new NSNumber(x.Offset)).ToArray();
else
{
int itemCount = gradientStops.Count;
int index = 0;
float step = 1.0f / itemCount;
NSNumber[] locations = new NSNumber[itemCount];
foreach (var gradientStop in gradientStops)
{
float location = step * index;
bool setLocation = !gradientStops.Any(gt => gt.Offset > location);
if (gradientStop.Offset == 0 && setLocation)
locations[index] = new NSNumber(location);
else
locations[index] = new NSNumber(gradientStop.Offset);
index++;
}
return locations;
}
}
static CGColor[] GetCAGradientLayerColors(List<PaintGradientStop> gradientStops)
{
if (gradientStops == null || gradientStops.Count == 0)
return Array.Empty<CGColor>();
CGColor[] colors = new CGColor[gradientStops.Count];
int index = 0;
foreach (var gradientStop in gradientStops)
{
if (gradientStop.Color == Colors.Transparent)
{
var color = gradientStops[index == 0 ? index + 1 : index - 1].Color;
CGColor nativeColor = color.ToPlatform().ColorWithAlpha(0.0f).CGColor;
colors[index] = nativeColor;
}
else
colors[index] = gradientStop.Color.ToCGColor();
index++;
}
return colors;
}
}
} | PaintExtensions |
csharp | MassTransit__MassTransit | tests/MassTransit.Tests/SagaStateMachineTests/Automatonymous/Exception_Specs.cs | {
"start": 17456,
"end": 18045
} | public class ____
{
[Test]
public void Should_finalize_in_catch_block()
{
Assert.That(_instance.CurrentState, Is.EqualTo(_machine.Final));
}
Instance _instance;
InstanceStateMachine _machine;
[OneTimeSetUp]
public async Task Specifying_an_event_activity()
{
_instance = new Instance();
_machine = new InstanceStateMachine();
await _machine.RaiseEvent(_instance, _machine.Initialized, new Init());
}
| When_an_action_throws_an_exception_and_catches_it |
csharp | ShareX__ShareX | ShareX.HistoryLib/HistoryManagerSQLite.cs | {
"start": 1178,
"end": 8814
} | public class ____ : HistoryManager, IDisposable
{
private SqliteConnection connection;
public HistoryManagerSQLite(string filePath) : base(filePath)
{
Connect(filePath);
EnsureDatabase();
}
private void Connect(string filePath)
{
FileHelpers.CreateDirectoryFromFilePath(filePath);
string connectionString = $"Data Source={filePath}";
connection = new SqliteConnection(connectionString);
connection.Open();
SetBusyTimeout(5000);
}
private void SetBusyTimeout(int milliseconds)
{
using (SqliteCommand cmd = connection.CreateCommand())
{
cmd.CommandText = $"PRAGMA busy_timeout = {milliseconds};";
cmd.ExecuteNonQuery();
}
}
private void EnsureDatabase()
{
using (SqliteCommand cmd = connection.CreateCommand())
{
cmd.CommandText = @"
CREATE TABLE IF NOT EXISTS History (
Id INTEGER PRIMARY KEY AUTOINCREMENT,
FileName TEXT,
FilePath TEXT,
DateTime TEXT,
Type TEXT,
Host TEXT,
URL TEXT,
ThumbnailURL TEXT,
DeletionURL TEXT,
ShortenedURL TEXT,
Tags TEXT
);
";
cmd.ExecuteNonQuery();
}
}
internal override List<HistoryItem> Load(string dbPath)
{
List<HistoryItem> items = new List<HistoryItem>();
using (SqliteCommand cmd = new SqliteCommand("SELECT * FROM History;", connection))
using (SqliteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
HistoryItem item = new HistoryItem()
{
Id = (long)reader["Id"],
FileName = reader["FileName"].ToString(),
FilePath = reader["FilePath"].ToString(),
DateTime = DateTime.Parse(reader["DateTime"].ToString()),
Type = reader["Type"].ToString(),
Host = reader["Host"].ToString(),
URL = reader["URL"].ToString(),
ThumbnailURL = reader["ThumbnailURL"].ToString(),
DeletionURL = reader["DeletionURL"].ToString(),
ShortenedURL = reader["ShortenedURL"].ToString(),
Tags = JsonConvert.DeserializeObject<Dictionary<string, string>>(reader["Tags"]?.ToString() ?? "{}")
};
items.Add(item);
}
}
return items;
}
protected override bool Append(string dbPath, IEnumerable<HistoryItem> historyItems)
{
using (SqliteTransaction transaction = connection.BeginTransaction())
{
foreach (HistoryItem item in historyItems)
{
using (SqliteCommand cmd = connection.CreateCommand())
{
cmd.CommandText = @"
INSERT INTO History
(FileName, FilePath, DateTime, Type, Host, URL, ThumbnailURL, DeletionURL, ShortenedURL, Tags)
VALUES (@FileName, @FilePath, @DateTime, @Type, @Host, @URL, @ThumbnailURL, @DeletionURL, @ShortenedURL, @Tags);
SELECT last_insert_rowid();";
cmd.Parameters.AddWithValue("@FileName", item.FileName ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@FilePath", item.FilePath ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@DateTime", item.DateTime.ToString("o") ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Type", item.Type ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Host", item.Host ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@URL", item.URL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@ThumbnailURL", item.ThumbnailURL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@DeletionURL", item.DeletionURL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@ShortenedURL", item.ShortenedURL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Tags", item.Tags != null ? JsonConvert.SerializeObject(item.Tags) : (object)DBNull.Value);
item.Id = (long)cmd.ExecuteScalar();
}
}
transaction.Commit();
}
return true;
}
public void Edit(HistoryItem item)
{
using (SqliteTransaction transaction = connection.BeginTransaction())
using (SqliteCommand cmd = connection.CreateCommand())
{
cmd.CommandText = @"
UPDATE History SET
FileName = @FileName,
FilePath = @FilePath,
DateTime = @DateTime,
Type = @Type,
Host = @Host,
URL = @URL,
ThumbnailURL = @ThumbnailURL,
DeletionURL = @DeletionURL,
ShortenedURL = @ShortenedURL,
Tags = @Tags
WHERE Id = @Id;";
cmd.Parameters.AddWithValue("@FileName", item.FileName ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@FilePath", item.FilePath ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@DateTime", item.DateTime.ToString("o") ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Type", item.Type ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Host", item.Host ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@URL", item.URL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@ThumbnailURL", item.ThumbnailURL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@DeletionURL", item.DeletionURL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@ShortenedURL", item.ShortenedURL ?? (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Tags", item.Tags != null ? JsonConvert.SerializeObject(item.Tags) : (object)DBNull.Value);
cmd.Parameters.AddWithValue("@Id", item.Id);
cmd.ExecuteNonQuery();
transaction.Commit();
}
}
public void Delete(params HistoryItem[] items)
{
if (items != null && items.Length > 0)
{
using (SqliteTransaction transaction = connection.BeginTransaction())
using (SqliteCommand cmd = connection.CreateCommand())
{
cmd.CommandText = "DELETE FROM History WHERE Id = @Id;";
SqliteParameter idParam = cmd.CreateParameter();
idParam.ParameterName = "@Id";
cmd.Parameters.Add(idParam);
foreach (HistoryItem item in items)
{
idParam.Value = item.Id;
cmd.ExecuteNonQuery();
}
transaction.Commit();
}
}
}
public void MigrateFromJSON(string jsonFilePath)
{
HistoryManagerJSON jsonManager = new HistoryManagerJSON(jsonFilePath);
List<HistoryItem> items = jsonManager.Load(jsonFilePath);
if (items.Count > 0)
{
Append(items);
}
}
public void Dispose()
{
connection?.Dispose();
}
}
} | HistoryManagerSQLite |
csharp | dotnet__aspnetcore | src/SignalR/samples/ClientSample/Tcp/TcpConnection.cs | {
"start": 485,
"end": 7072
} | public class ____ : ConnectionContext, IConnectionInherentKeepAliveFeature
{
private readonly Socket _socket;
private volatile bool _aborted;
private readonly EndPoint _endPoint;
private IDuplexPipe _application;
private readonly SocketSender _sender;
private readonly SocketReceiver _receiver;
public TcpConnection(EndPoint endPoint)
{
_socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_endPoint = endPoint;
_sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
_receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
// Add IConnectionInherentKeepAliveFeature to the tcp connection impl since Kestrel doesn't implement
// the IConnectionHeartbeatFeature
Features.Set<IConnectionInherentKeepAliveFeature>(this);
}
public override IDuplexPipe Transport { get; set; }
public override IFeatureCollection Features { get; } = new FeatureCollection();
public override string ConnectionId { get; set; } = Guid.NewGuid().ToString();
public override IDictionary<object, object> Items { get; set; } = new ConnectionItems();
// We claim to have inherent keep-alive so the client doesn't kill the connection when it hasn't seen ping frames.
public bool HasInherentKeepAlive { get; } = true;
public override ValueTask DisposeAsync()
{
Transport?.Output.Complete();
Transport?.Input.Complete();
_socket?.Dispose();
return default;
}
public async ValueTask<ConnectionContext> StartAsync()
{
await _socket.ConnectAsync(_endPoint);
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
Transport = pair.Transport;
_application = pair.Application;
_ = ExecuteAsync();
return this;
}
private async Task ExecuteAsync()
{
Exception sendError = null;
try
{
// Spawn send and receive logic
var receiveTask = DoReceive();
var sendTask = DoSend();
// If the sending task completes then close the receive
// We don't need to do this in the other direction because the kestrel
// will trigger the output closing once the input is complete.
if (await Task.WhenAny(receiveTask, sendTask) == sendTask)
{
// Tell the reader it's being aborted
_socket.Dispose();
}
// Now wait for both to complete
await receiveTask;
sendError = await sendTask;
// Dispose the socket(should noop if already called)
_socket.Dispose();
}
catch (Exception ex)
{
Console.WriteLine($"Unexpected exception in {nameof(TcpConnection)}.{nameof(StartAsync)}: " + ex);
}
finally
{
// Complete the output after disposing the socket
_application.Input.Complete(sendError);
}
}
private async Task DoReceive()
{
Exception error = null;
try
{
await ProcessReceives();
}
catch (SocketException ex) when (ex.SocketErrorCode == SocketError.ConnectionReset)
{
error = new ConnectionResetException(ex.Message, ex);
}
catch (SocketException ex) when (ex.SocketErrorCode == SocketError.OperationAborted ||
ex.SocketErrorCode == SocketError.ConnectionAborted ||
ex.SocketErrorCode == SocketError.Interrupted ||
ex.SocketErrorCode == SocketError.InvalidArgument)
{
if (!_aborted)
{
// Calling Dispose after ReceiveAsync can cause an "InvalidArgument" error on *nix.
error = new ConnectionAbortedException();
}
}
catch (ObjectDisposedException)
{
if (!_aborted)
{
error = new ConnectionAbortedException();
}
}
catch (IOException ex)
{
error = ex;
}
catch (Exception ex)
{
error = new IOException(ex.Message, ex);
}
finally
{
if (_aborted)
{
error = error ?? new ConnectionAbortedException();
}
_application.Output.Complete(error);
}
}
private async Task ProcessReceives()
{
while (true)
{
// Ensure we have some reasonable amount of buffer space
var buffer = _application.Output.GetMemory();
var bytesReceived = await _receiver.ReceiveAsync(buffer);
if (bytesReceived == 0)
{
// FIN
break;
}
_application.Output.Advance(bytesReceived);
var result = await _application.Output.FlushAsync();
if (result.IsCompleted)
{
// Pipe consumer is shut down, do we stop writing
break;
}
}
}
private async Task<Exception> DoSend()
{
Exception error = null;
try
{
await ProcessSends();
}
catch (SocketException ex) when (ex.SocketErrorCode == SocketError.OperationAborted)
{
error = null;
}
catch (ObjectDisposedException)
{
error = null;
}
catch (IOException ex)
{
error = ex;
}
catch (Exception ex)
{
error = new IOException(ex.Message, ex);
}
finally
{
_aborted = true;
_socket.Shutdown(SocketShutdown.Both);
}
return error;
}
private async Task ProcessSends()
{
while (true)
{
// Wait for data to write from the pipe producer
var result = await _application.Input.ReadAsync();
var buffer = result.Buffer;
if (result.IsCanceled)
{
break;
}
var end = buffer.End;
var isCompleted = result.IsCompleted;
if (!buffer.IsEmpty)
{
await _sender.SendAsync(buffer);
}
_application.Input.AdvanceTo(end);
if (isCompleted)
{
break;
}
}
}
}
| TcpConnection |
csharp | ServiceStack__ServiceStack | ServiceStack.Blazor/tests/UI.Gallery/Gallery/MyApp/Configure.Markdown.cs | {
"start": 161,
"end": 1891
} | public class ____ : IHostingStartup
{
public void Configure(IWebHostBuilder builder) => builder
.ConfigureServices((context, services) =>
{
context.Configuration.GetSection(nameof(AppConfig)).Bind(AppConfig.Instance);
services.AddSingleton(AppConfig.Instance);
services.AddSingleton<MarkdownPages>();
services.AddSingleton<MarkdownVideos>();
services.AddPlugin(new CleanUrlsFeature());
})
.ConfigureAppHost(
afterPluginsLoaded: appHost =>
{
var pages = appHost.Resolve<MarkdownPages>();
var videos = appHost.Resolve<MarkdownVideos>();
new IMarkdownPages[] { pages, videos }
.Each(x => x.VirtualFiles = appHost.VirtualFiles);
pages.LoadFrom("_pages");
videos.LoadFrom("_videos");
AppConfig.Instance.GitPagesBaseUrl ??= ResolveGitBlobBaseUrl(appHost.ContentRootDirectory);
});
private string? ResolveGitBlobBaseUrl(IVirtualDirectory contentDir)
{
var srcDir = new DirectoryInfo(contentDir.RealPath);
var gitConfig = new FileInfo(Path.Combine(srcDir.Parent!.FullName, ".git", "config"));
if (gitConfig.Exists)
{
var txt = gitConfig.ReadAllText();
var pos = txt.IndexOf("url = ", StringComparison.Ordinal);
if (pos >= 0)
{
var url = txt[(pos + "url = ".Length)..].LeftPart(".git").LeftPart('\n').Trim();
var gitBaseUrl = url.CombineWith($"blob/main/{srcDir.Name}");
return gitBaseUrl;
}
}
return null;
}
}
| ConfigureSsg |
csharp | ServiceStack__ServiceStack.OrmLite | tests/ServiceStack.OrmLite.MySql.Tests/Issues/CustomMappingIssue.cs | {
"start": 1546,
"end": 3424
} | public class ____
{
[AutoIncrement]
[PrimaryKey]
public long check_id { get; set; }
public long room_state_id { get; set; }
public DateTime? entry_stamp { get; set; }
public int student_id { get; set; }
public string reason { get; set; }
public string comments { get; set; }
public long check_type_id { get; set; }
public DateTime? check_dt { get; set; }
public byte grace { get; set; }
public DateTime curfew_dt { get; set; }
public int excused_by { get; set; }
public string status { get; set; }
public int points { get; set; }
public string check_class { get; set; }
public int leave_id { get; set; }
public DateTime night_of { get; set; }
public DateTime violation_dt { get; set; }
public string excused_reason { get; set; }
public DateTime? excused_dt { get; set; }
public bool imported { get; set; } //tinyint(1) returned as `bool`
}
[Test]
public void Does_map_to_checks_table()
{
LogManager.LogFactory = new ConsoleLogFactory();
using (var db = OpenDbConnection())
{
db.DropTable<Check>();
db.ExecuteSql(CreateChecksTableSql);
db.Insert(new Check
{
room_state_id = 1,
student_id = 2,
reason = "reason",
grace = 1,
imported = false,
status = "s",
check_class = "ch",
excused_reason = "excused_reason",
});
db.Select<Check>().PrintDump();
}
}
}
} | Check |
csharp | npgsql__npgsql | src/Npgsql/Internal/Postgres/DataTypeNames.cs | {
"start": 176,
"end": 7087
} | static class ____
{
// Generated from the following query:
// SELECT '"' || string_agg(typname, '" or "') || '"' FROM (
// SELECT typname FROM pg_catalog.pg_type WHERE typtype = 'b' AND typcategory <> 'A'
// AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'pg_catalog') ORDER BY typname);
public static bool IsWellKnownUnqualifiedName(ReadOnlySpan<char> name) => name switch
{
"aclitem" or "bit" or "bool" or "box" or "bpchar" or "bytea" or "char" or "cid" or
"cidr" or "circle" or "date" or "float4" or "float8" or "gtsvector" or "inet" or
"int2" or "int4" or "int8" or "interval" or "json" or "jsonb" or "jsonpath" or
"line" or "lseg" or "macaddr" or "macaddr8" or "money" or "name" or "numeric" or
"oid" or "path" or "pg_brin_bloom_summary" or "pg_brin_minmax_multi_summary" or
"pg_dependencies" or "pg_lsn" or "pg_mcv_list" or "pg_ndistinct" or "pg_node_tree" or
"pg_snapshot" or "point" or "polygon" or "refcursor" or "regclass" or "regcollation" or
"regconfig" or "regdictionary" or "regnamespace" or "regoper" or "regoperator" or
"regproc" or "regprocedure" or "regrole" or "regtype" or "text" or "tid" or "time" or
"timestamp" or "timestamptz" or "timetz" or "tsquery" or "tsvector" or "txid_snapshot" or
"uuid" or "varbit" or "varchar" or "xid" or "xid8" or "xml"
=> true,
_ => false
};
// Note: The names are fully qualified in source so the strings are constants and instances will be interned after the first call.
// Uses an internal constructor bypassing the public DataTypeName constructor validation, as we don't want to store all these names on
// fields either.
public static DataTypeName Int2 => ValidatedName("pg_catalog.int2");
public static DataTypeName Int4 => ValidatedName("pg_catalog.int4");
public static DataTypeName Int4Range => ValidatedName("pg_catalog.int4range");
public static DataTypeName Int4Multirange => ValidatedName("pg_catalog.int4multirange");
public static DataTypeName Int8 => ValidatedName("pg_catalog.int8");
public static DataTypeName Int8Range => ValidatedName("pg_catalog.int8range");
public static DataTypeName Int8Multirange => ValidatedName("pg_catalog.int8multirange");
public static DataTypeName Float4 => ValidatedName("pg_catalog.float4");
public static DataTypeName Float8 => ValidatedName("pg_catalog.float8");
public static DataTypeName Numeric => ValidatedName("pg_catalog.numeric");
public static DataTypeName NumRange => ValidatedName("pg_catalog.numrange");
public static DataTypeName NumMultirange => ValidatedName("pg_catalog.nummultirange");
public static DataTypeName Money => ValidatedName("pg_catalog.money");
public static DataTypeName Bool => ValidatedName("pg_catalog.bool");
public static DataTypeName Box => ValidatedName("pg_catalog.box");
public static DataTypeName Circle => ValidatedName("pg_catalog.circle");
public static DataTypeName Line => ValidatedName("pg_catalog.line");
public static DataTypeName LSeg => ValidatedName("pg_catalog.lseg");
public static DataTypeName Path => ValidatedName("pg_catalog.path");
public static DataTypeName Point => ValidatedName("pg_catalog.point");
public static DataTypeName Polygon => ValidatedName("pg_catalog.polygon");
public static DataTypeName Bpchar => ValidatedName("pg_catalog.bpchar");
public static DataTypeName Text => ValidatedName("pg_catalog.text");
public static DataTypeName Varchar => ValidatedName("pg_catalog.varchar");
public static DataTypeName Char => ValidatedName("pg_catalog.char");
public static DataTypeName Name => ValidatedName("pg_catalog.name");
public static DataTypeName Bytea => ValidatedName("pg_catalog.bytea");
public static DataTypeName Date => ValidatedName("pg_catalog.date");
public static DataTypeName DateRange => ValidatedName("pg_catalog.daterange");
public static DataTypeName DateMultirange => ValidatedName("pg_catalog.datemultirange");
public static DataTypeName Time => ValidatedName("pg_catalog.time");
public static DataTypeName Timestamp => ValidatedName("pg_catalog.timestamp");
public static DataTypeName TsRange => ValidatedName("pg_catalog.tsrange");
public static DataTypeName TsMultirange => ValidatedName("pg_catalog.tsmultirange");
public static DataTypeName TimestampTz => ValidatedName("pg_catalog.timestamptz");
public static DataTypeName TsTzRange => ValidatedName("pg_catalog.tstzrange");
public static DataTypeName TsTzMultirange => ValidatedName("pg_catalog.tstzmultirange");
public static DataTypeName Interval => ValidatedName("pg_catalog.interval");
public static DataTypeName TimeTz => ValidatedName("pg_catalog.timetz");
public static DataTypeName Inet => ValidatedName("pg_catalog.inet");
public static DataTypeName Cidr => ValidatedName("pg_catalog.cidr");
public static DataTypeName MacAddr => ValidatedName("pg_catalog.macaddr");
public static DataTypeName MacAddr8 => ValidatedName("pg_catalog.macaddr8");
public static DataTypeName Bit => ValidatedName("pg_catalog.bit");
public static DataTypeName Varbit => ValidatedName("pg_catalog.varbit");
public static DataTypeName TsVector => ValidatedName("pg_catalog.tsvector");
public static DataTypeName TsQuery => ValidatedName("pg_catalog.tsquery");
public static DataTypeName RegConfig => ValidatedName("pg_catalog.regconfig");
public static DataTypeName Uuid => ValidatedName("pg_catalog.uuid");
public static DataTypeName Xml => ValidatedName("pg_catalog.xml");
public static DataTypeName Json => ValidatedName("pg_catalog.json");
public static DataTypeName Jsonb => ValidatedName("pg_catalog.jsonb");
public static DataTypeName Jsonpath => ValidatedName("pg_catalog.jsonpath");
public static DataTypeName Record => ValidatedName("pg_catalog.record");
public static DataTypeName RefCursor => ValidatedName("pg_catalog.refcursor");
public static DataTypeName OidVector => ValidatedName("pg_catalog.oidvector");
public static DataTypeName Int2Vector => ValidatedName("pg_catalog.int2vector");
public static DataTypeName Oid => ValidatedName("pg_catalog.oid");
public static DataTypeName Xid => ValidatedName("pg_catalog.xid");
public static DataTypeName Xid8 => ValidatedName("pg_catalog.xid8");
public static DataTypeName Cid => ValidatedName("pg_catalog.cid");
public static DataTypeName RegType => ValidatedName("pg_catalog.regtype");
public static DataTypeName Tid => ValidatedName("pg_catalog.tid");
public static DataTypeName PgLsn => ValidatedName("pg_catalog.pg_lsn");
public static DataTypeName Unknown => ValidatedName("pg_catalog.unknown");
public static DataTypeName Void => ValidatedName("pg_catalog.void");
}
| DataTypeNames |
csharp | dotnet__efcore | test/EFCore.Specification.Tests/PropertyValuesTestBase.cs | {
"start": 165791,
"end": 165871
} | protected struct ____
{
public string? Text { get; set; }
}
| Tog |
csharp | ardalis__CleanArchitecture | sample/tests/NimblePros.SampleToDo.UnitTests/ToDoItemBuilder.cs | {
"start": 208,
"end": 818
} | public class ____
{
private ToDoItem _todo = new ToDoItem();
public ToDoItemBuilder Id(int id)
{
_todo.Id = ToDoItemId.From(id);
return this;
}
public ToDoItemBuilder Title(string title)
{
_todo.Title = title;
return this;
}
public ToDoItemBuilder Description(string description)
{
_todo.Description = description;
return this;
}
public ToDoItemBuilder WithDefaultValues()
{
_todo = new ToDoItem() { Id = ToDoItemId.From(1), Title = "Test Item", Description = "Test Description" };
return this;
}
public ToDoItem Build() => _todo;
}
| ToDoItemBuilder |
csharp | EventStore__EventStore | src/KurrentDB.Core.Tests/Services/Storage/Transactions/when_having_two_intermingled_transactions_and_some_uncommitted_prepares_in_the_end_read_index_should.cs | {
"start": 631,
"end": 12083
} | public class
____<TLogFormat, TStreamId> :
ReadIndexTestScenario<TLogFormat, TStreamId> {
private EventRecord _p1;
private EventRecord _p2;
private EventRecord _p3;
private EventRecord _p4;
private EventRecord _p5;
private long _pos6, _pos7, _pos8;
private long _t1CommitPos;
private long _t2CommitPos;
protected override async ValueTask WriteTestScenario(CancellationToken token) {
const string streamId1 = "ES";
const string streamId2 = "ABC";
var t1 = await WriteTransactionBegin(streamId1, ExpectedVersion.NoStream, token);
var t2 = await WriteTransactionBegin(streamId2, ExpectedVersion.NoStream, token);
_p1 = await WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 0, streamId1, 0, "es1",
PrepareFlags.Data, token: token);
_p2 = await WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 0, streamId2, 0, "abc1",
PrepareFlags.Data, token: token);
_p3 = await WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 1, streamId1, 1, "es1",
PrepareFlags.Data, token: token);
_p4 = await WriteTransactionEvent(t2.CorrelationId, t2.LogPosition, 1, streamId2, 1, "abc1",
PrepareFlags.Data, token: token);
_p5 = await WriteTransactionEvent(t1.CorrelationId, t1.LogPosition, 2, streamId1, 2, "es1",
PrepareFlags.Data, token: token);
await WriteTransactionEnd(t2.CorrelationId, t2.TransactionPosition, streamId2, token);
await WriteTransactionEnd(t1.CorrelationId, t1.TransactionPosition, streamId1, token);
_t2CommitPos = await WriteCommit(t2.CorrelationId, t2.TransactionPosition, streamId2, _p2.EventNumber, token);
_t1CommitPos = await WriteCommit(t1.CorrelationId, t1.TransactionPosition, streamId1, _p1.EventNumber, token);
var (t1StreamId, _) = await GetOrReserve("t1", token);
(var eventTypeId, _pos6) = await GetOrReserveEventType("et", token);
var r6 = LogRecord.Prepare(_recordFactory, _pos6, Guid.NewGuid(), Guid.NewGuid(), _pos6, 0, t1StreamId, -1,
PrepareFlags.SingleWrite, eventTypeId, LogRecord.NoData, LogRecord.NoData);
(_, _pos7) = await Writer.Write(r6, token);
var r7 = LogRecord.Prepare(_recordFactory, _pos7, Guid.NewGuid(), Guid.NewGuid(), _pos7, 0, t1StreamId, -1,
PrepareFlags.SingleWrite, eventTypeId, LogRecord.NoData, LogRecord.NoData);
(_, _pos8) = await Writer.Write(r7, token);
var r8 = LogRecord.Prepare(_recordFactory, _pos8, Guid.NewGuid(), Guid.NewGuid(), _pos8, 0, t1StreamId, -1,
PrepareFlags.SingleWrite, eventTypeId, LogRecord.NoData, LogRecord.NoData);
await Writer.Write(r8, token);
}
[Test]
public async Task read_all_events_forward_returns_all_events_in_correct_order() {
var records = (await ReadIndex.ReadAllEventsForward(new TFPos(0, 0), 10, CancellationToken.None))
.Records;
Assert.AreEqual(5, records.Count);
Assert.AreEqual(_p2, records[0].Event);
Assert.AreEqual(_p4, records[1].Event);
Assert.AreEqual(_p1, records[2].Event);
Assert.AreEqual(_p3, records[3].Event);
Assert.AreEqual(_p5, records[4].Event);
}
[Test]
public async Task read_all_events_backward_returns_all_events_in_correct_order() {
var records = (await ReadIndex.ReadAllEventsBackward(GetBackwardReadPos(), 10, CancellationToken.None)).Records;
Assert.AreEqual(5, records.Count);
Assert.AreEqual(_p5, records[0].Event);
Assert.AreEqual(_p3, records[1].Event);
Assert.AreEqual(_p1, records[2].Event);
Assert.AreEqual(_p4, records[3].Event);
Assert.AreEqual(_p2, records[4].Event);
}
[Test]
public async Task
read_all_events_forward_returns_nothing_when_prepare_position_is_greater_than_last_prepare_in_commit() {
var records = (await ReadIndex.ReadAllEventsForward(new TFPos(_t1CommitPos, _t1CommitPos), 10, CancellationToken.None))
.Records;
Assert.AreEqual(0, records.Count);
}
[Test]
public async Task
read_all_events_backwards_returns_nothing_when_prepare_position_is_smaller_than_first_prepare_in_commit() {
var records =
(await ReadIndex.ReadAllEventsBackward(new TFPos(_t2CommitPos, 0), 10, CancellationToken.None)).Records;
Assert.AreEqual(0, records.Count);
}
[Test]
public async Task read_all_events_forward_returns_correct_events_starting_in_the_middle_of_tf() {
var res1 = await ReadIndex.ReadAllEventsForward(new TFPos(_t2CommitPos, _p4.LogPosition), 10, CancellationToken.None);
Assert.AreEqual(4, res1.Records.Count);
Assert.AreEqual(_p4, res1.Records[0].Event);
Assert.AreEqual(_p1, res1.Records[1].Event);
Assert.AreEqual(_p3, res1.Records[2].Event);
Assert.AreEqual(_p5, res1.Records[3].Event);
var res2 = await ReadIndex.ReadAllEventsBackward(res1.PrevPos, 10, CancellationToken.None);
Assert.AreEqual(1, res2.Records.Count);
Assert.AreEqual(_p2, res2.Records[0].Event);
}
[Test]
public async Task read_all_events_backward_returns_correct_events_starting_in_the_middle_of_tf() {
var pos = new TFPos(_pos6, _p4.LogPosition); // p3 post-pos
var res1 = await ReadIndex.ReadAllEventsBackward(pos, 10, CancellationToken.None);
Assert.AreEqual(4, res1.Records.Count);
Assert.AreEqual(_p3, res1.Records[0].Event);
Assert.AreEqual(_p1, res1.Records[1].Event);
Assert.AreEqual(_p4, res1.Records[2].Event);
Assert.AreEqual(_p2, res1.Records[3].Event);
var res2 = await ReadIndex.ReadAllEventsForward(res1.PrevPos, 10, CancellationToken.None);
Assert.AreEqual(1, res2.Records.Count);
Assert.AreEqual(_p5, res2.Records[0].Event);
}
[Test]
public async Task all_records_can_be_read_sequentially_page_by_page_in_forward_pass() {
var recs = new[] { _p2, _p4, _p1, _p3, _p5 }; // in committed order
int count = 0;
var pos = new TFPos(0, 0);
IndexReadAllResult result;
while ((result = await ReadIndex.ReadAllEventsForward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task all_records_can_be_read_sequentially_page_by_page_in_backward_pass() {
var recs = new[] { _p5, _p3, _p1, _p4, _p2 }; // in reverse committed order
int count = 0;
var pos = GetBackwardReadPos();
IndexReadAllResult result;
while ((result = await ReadIndex.ReadAllEventsBackward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task position_returned_for_prev_page_when_traversing_forward_allow_to_traverse_backward_correctly() {
var recs = new[] { _p2, _p4, _p1, _p3, _p5 }; // in committed order
int count = 0;
var pos = new TFPos(0, 0);
IndexReadAllResult result;
while ((result = await ReadIndex.ReadAllEventsForward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
var localPos = result.PrevPos;
int localCount = 0;
IndexReadAllResult localResult;
while ((localResult = await ReadIndex.ReadAllEventsBackward(localPos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, localResult.Records.Count);
Assert.AreEqual(recs[count - 1 - localCount], localResult.Records[0].Event);
localPos = localResult.NextPos;
localCount += 1;
}
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task position_returned_for_prev_page_when_traversing_backward_allow_to_traverse_forward_correctly() {
var recs = new[] { _p5, _p3, _p1, _p4, _p2 }; // in reverse committed order
int count = 0;
var pos = GetBackwardReadPos();
IndexReadAllResult result;
while ((result = await ReadIndex.ReadAllEventsBackward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
var localPos = result.PrevPos;
int localCount = 0;
IndexReadAllResult localResult;
while ((localResult = await ReadIndex.ReadAllEventsForward(localPos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, localResult.Records.Count);
Assert.AreEqual(recs[count - 1 - localCount], localResult.Records[0].Event);
localPos = localResult.NextPos;
localCount += 1;
}
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task
reading_all_forward_at_position_with_no_commits_after_returns_prev_pos_that_allows_to_traverse_back() {
var res1 = await ReadIndex.ReadAllEventsForward(new TFPos(_pos6, 0), 100, CancellationToken.None);
Assert.AreEqual(0, res1.Records.Count);
var recs = new[] { _p5, _p3, _p1, _p4, _p2 }; // in reverse committed order
int count = 0;
IndexReadAllResult result;
TFPos pos = res1.PrevPos;
while ((result = await ReadIndex.ReadAllEventsBackward(pos, 1, CancellationToken.None)).Records.Count !=
0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task reading_all_forward_at_the_very_end_returns_prev_pos_that_allows_to_traverse_back() {
var res1 = await ReadIndex.ReadAllEventsForward(new TFPos(Db.Config.WriterCheckpoint.Read(), 0), 100, CancellationToken.None);
Assert.AreEqual(0, res1.Records.Count);
var recs = new[] { _p5, _p3, _p1, _p4, _p2 }; // in reverse committed order
int count = 0;
IndexReadAllResult result;
TFPos pos = res1.PrevPos;
while ((result = await ReadIndex.ReadAllEventsBackward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task
reading_all_backward_at_position_with_no_commits_before_returns_prev_pos_that_allows_to_traverse_forward() {
var res1 = await ReadIndex.ReadAllEventsBackward(new TFPos(_t2CommitPos, int.MaxValue), 100, CancellationToken.None);
Assert.AreEqual(0, res1.Records.Count);
var recs = new[] { _p2, _p4, _p1, _p3, _p5 };
int count = 0;
IndexReadAllResult result;
TFPos pos = res1.PrevPos;
while ((result = await ReadIndex.ReadAllEventsForward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
[Test]
public async Task reading_all_backward_at_the_very_beginning_returns_prev_pos_that_allows_to_traverse_forward() {
var res1 = await ReadIndex.ReadAllEventsBackward(new TFPos(0, int.MaxValue), 100, CancellationToken.None);
Assert.AreEqual(0, res1.Records.Count);
var recs = new[] { _p2, _p4, _p1, _p3, _p5 };
int count = 0;
IndexReadAllResult result;
TFPos pos = res1.PrevPos;
while ((result = await ReadIndex.ReadAllEventsForward(pos, 1, CancellationToken.None)).Records.Count != 0) {
Assert.AreEqual(1, result.Records.Count);
Assert.AreEqual(recs[count], result.Records[0].Event);
pos = result.NextPos;
count += 1;
}
Assert.AreEqual(recs.Length, count);
}
}
| when_having_two_intermingled_transactions_and_some_uncommitted_prepares_in_the_end_read_index_should |
csharp | dotnetcore__FreeSql | FreeSql.Tests/FreeSql.Tests/KingbaseES/MapType/DateTimeOffSetTest.cs | {
"start": 176,
"end": 2380
} | class ____
{
public Guid id { get; set; }
[Column(MapType = typeof(DateTime))]
public DateTimeOffset dtos_to_dt { get; set; }
[Column(MapType = typeof(DateTime))]
public DateTimeOffset? dtofnil_to_dt { get; set; }
}
[Fact]
public void DateTimeToDateTimeOffSet()
{
//insert
var orm = g.kingbaseES;
var item = new Dtos_dt { dtos_to_dt = DateTimeOffset.Now, dtofnil_to_dt = DateTimeOffset.Now };
Assert.Equal(1, orm.Insert<Dtos_dt>().AppendData(item).ExecuteAffrows());
var find = orm.Select<Dtos_dt>().Where(a => a.id == item.id).First();
Assert.NotNull(find);
Assert.Equal(item.id, find.id);
Assert.Equal(item.dtos_to_dt.ToString("g"), find.dtos_to_dt.ToString("g"));
Assert.Equal(item.dtofnil_to_dt.Value.ToString("g"), find.dtofnil_to_dt.Value.ToString("g"));
//update all
item.dtos_to_dt = DateTimeOffset.Now;
Assert.Equal(1, orm.Update<Dtos_dt>().SetSource(item).ExecuteAffrows());
find = orm.Select<Dtos_dt>().Where(a => a.id == item.id).First();
Assert.NotNull(find);
Assert.Equal(item.id, find.id);
Assert.Equal(item.dtos_to_dt.ToString("g"), find.dtos_to_dt.ToString("g"));
Assert.Equal(item.dtofnil_to_dt.Value.ToString("g"), find.dtofnil_to_dt.Value.ToString("g"));
//update set
Assert.Equal(1, orm.Update<Dtos_dt>().Where(a => a.id == item.id).Set(a => a.dtos_to_dt, item.dtos_to_dt = DateTimeOffset.Now).ExecuteAffrows());
find = orm.Select<Dtos_dt>().Where(a => a.id == item.id).First();
Assert.NotNull(find);
Assert.Equal(item.dtos_to_dt.ToString("g"), find.dtos_to_dt.ToString("g"));
Assert.Equal(item.dtofnil_to_dt.Value.ToString("g"), find.dtofnil_to_dt.Value.ToString("g"));
//delete
Assert.Equal(1, orm.Delete<Dtos_dt>().Where(a => a.id == item.id).ExecuteAffrows());
Assert.Null(orm.Select<Dtos_dt>().Where(a => a.id == item.id).First());
}
}
}
| Dtos_dt |
csharp | dotnet__maui | src/Controls/src/Core/Interactivity/DataTrigger.cs | {
"start": 316,
"end": 1911
} | public sealed class ____ : TriggerBase
{
/// <include file="../../../docs/Microsoft.Maui.Controls/DataTrigger.xml" path="//Member[@MemberName='.ctor']/Docs/*" />
public DataTrigger([System.ComponentModel.TypeConverter(typeof(TypeTypeConverter))][Parameter("TargetType")] Type targetType) : base(new BindingCondition(), targetType)
{
}
/// <include file="../../../docs/Microsoft.Maui.Controls/DataTrigger.xml" path="//Member[@MemberName='Binding']/Docs/*" />
public BindingBase Binding
{
get { return ((BindingCondition)Condition).Binding; }
set
{
if (((BindingCondition)Condition).Binding == value)
return;
if (IsSealed)
throw new InvalidOperationException("Cannot change Binding once the Trigger has been applied.");
OnPropertyChanging();
((BindingCondition)Condition).Binding = value;
OnPropertyChanged();
}
}
/// <include file="../../../docs/Microsoft.Maui.Controls/DataTrigger.xml" path="//Member[@MemberName='Setters']/Docs/*" />
public new IList<Setter> Setters
{
get { return base.Setters; }
}
/// <include file="../../../docs/Microsoft.Maui.Controls/DataTrigger.xml" path="//Member[@MemberName='Value']/Docs/*" />
public object Value
{
get { return ((BindingCondition)Condition).Value; }
set
{
if (((BindingCondition)Condition).Value == value)
return;
if (IsSealed)
throw new InvalidOperationException("Cannot change Value once the Trigger has been applied.");
OnPropertyChanging();
((BindingCondition)Condition).Value = value;
OnPropertyChanged();
}
}
}
} | DataTrigger |
csharp | nunit__nunit | src/NUnitFramework/framework/Internal/Extensions/ArgumentsExtensions.cs | {
"start": 217,
"end": 1754
} | internal static class ____
{
/// <summary>
/// Checks if the last element of an argument list is a <see cref="CancellationToken"/>
/// </summary>
public static bool LastArgumentIsCancellationToken(this object?[] arguments)
{
return arguments.Length > 0 && arguments[arguments.Length - 1]?.GetType() == typeof(CancellationToken);
}
/// <summary>
/// Checks if the last type of a parameter list has a type <see cref="CancellationToken"/>
/// </summary>
public static bool LastParameterAcceptsCancellationToken(this IParameterInfo[] parameters)
{
return parameters.Length > 0 && parameters[parameters.Length - 1].ParameterType == typeof(CancellationToken);
}
/// <summary>
/// Checks if the parameter is a 'params' array.
/// </summary>
public static bool ParameterIsParamsArray(this IParameterInfo lastParameter)
{
return lastParameter.ParameterType.IsArray && lastParameter.IsDefined<ParamArrayAttribute>(false);
}
/// <summary>
/// Checks if the last parameter in a parameter list is a 'params' array.
/// </summary>
public static bool LastParameterIsParamsArray(this IParameterInfo[] parameters)
{
if (parameters.Length == 0)
{
return false;
}
return parameters[parameters.Length - 1].ParameterIsParamsArray();
}
}
}
| ArgumentsExtensions |
csharp | graphql-dotnet__graphql-dotnet | src/GraphQL.Tests/Types/Vector3ScalarTests.cs | {
"start": 2370,
"end": 2532
} | public class ____ : Schema
{
public Vector3ScalarSchema()
{
Query = new Vector3ScalarQuery();
}
}
| Vector3ScalarSchema |
csharp | MaterialDesignInXAML__MaterialDesignInXamlToolkit | tests/MaterialDesignThemes.UITests/Samples/AutoSuggestBoxes/AutoSuggestTextBoxWithInteractiveTemplate.xaml.cs | {
"start": 509,
"end": 1739
} | public partial class ____ : ObservableObject
{
private readonly List<SuggestionThing2> _baseSuggestions;
[ObservableProperty]
private List<SuggestionThing2> _suggestions = [];
[ObservableProperty]
private string? _autoSuggestText;
partial void OnAutoSuggestTextChanged(string? value)
{
if (!string.IsNullOrWhiteSpace(value))
{
var searchResult = _baseSuggestions.Where(x => IsMatch(x.Name, value));
Suggestions = new(searchResult);
}
else
{
Suggestions = new(_baseSuggestions);
}
}
public AutoSuggestTextBoxWithInteractiveTemplateViewModel()
{
_baseSuggestions =
[
new("Apples"),
new("Bananas"),
new("Beans"),
new("Mtn Dew"),
new("Orange")
];
Suggestions = [.. _baseSuggestions];
}
private static bool IsMatch(string item, string currentText)
{
#if NET6_0_OR_GREATER
return item.Contains(currentText, StringComparison.OrdinalIgnoreCase);
#else
return item.IndexOf(currentText, StringComparison.OrdinalIgnoreCase) >= 0;
#endif
}
}
| AutoSuggestTextBoxWithInteractiveTemplateViewModel |
csharp | unoplatform__uno | src/Uno.UI/DirectUI/JoltCollections.h.cs | {
"start": 27268,
"end": 28286
} | class ____<xaml_docs.TextRange> :
// public PresentationFrameworkCollectionTemplateBase<xaml_docs.TextRange>
// {
// public:
// // IVector<wf.TextRange> implementation
// IFACEMETHOD(Append)( xaml_docs.TextRange item) override;
// IFACEMETHOD(GetAt)( uint index, out xaml_docs.TextRange item) override;
// IFACEMETHOD(InsertAt)( uint index, xaml_docs.TextRange item) override;
// IFACEMETHOD(IndexOf)( xaml_docs.TextRange value, out uint index, out bool found) override;
// };
//#pragma endregion
//#pragma region ValueType Collections
// // DEPRECATED: All of these have WRL-equivalent implementations. It's unclear why they were
// // historically used, maybe WRL collections weren't available yet, but they probably have
// // subtle differences in behavior from the official collections which means we must keep
// // them around for now until we can remove their usage sites under a quirk.
// //
// // Do not use these in new code.
// template<typename T>
// | PresentationFrameworkCollection |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Core/test/Authorization.Tests/CodeFirstAuthorizationTests.cs | {
"start": 16541,
"end": 16807
} | private sealed class ____
{
public Person? GetPerson()
=> new("Joe");
public ICityOrStreet? GetCityOrStreet(bool street)
=> street
? new Street("Somewhere")
: new City("Else");
}
| Query |
csharp | MassTransit__MassTransit | src/MassTransit/Configuration/Configuration/CompositePredicate.cs | {
"start": 124,
"end": 1299
} | public class ____<T>
{
readonly List<Func<T, bool>> _list = new List<Func<T, bool>>();
Func<T, bool> _matchesAll = x => true;
Func<T, bool> _matchesAny = x => true;
Func<T, bool> _matchesNone = x => false;
public void Add(Func<T, bool> filter)
{
_matchesAll = x => _list.All(predicate => predicate(x));
_matchesAny = x => _list.Any(predicate => predicate(x));
_matchesNone = x => !MatchesAny(x);
_list.Add(filter);
}
public static CompositePredicate<T> operator +(CompositePredicate<T> invokes, Func<T, bool> filter)
{
invokes.Add(filter);
return invokes;
}
public bool MatchesAll(T target)
{
return _matchesAll(target);
}
public bool MatchesAny(T target)
{
return _matchesAny(target);
}
public bool MatchesNone(T target)
{
return _matchesNone(target);
}
public bool DoesNotMatcheAny(T target)
{
return _list.Count == 0 || !MatchesAny(target);
}
}
}
| CompositePredicate |
csharp | dotnet__efcore | test/EFCore.SqlServer.FunctionalTests/SeedingSqlServerTest.cs | {
"start": 487,
"end": 772
} | protected class ____(string testId) : SeedingContext(testId)
{
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
=> optionsBuilder.UseSqlServer(SqlServerTestStore.CreateConnectionString($"Seeds{TestId}"));
}
}
| SeedingSqlServerContext |
csharp | EventStore__EventStore | src/Connectors/KurrentDB.Connectors/Planes/Management/RequestValidation.cs | {
"start": 435,
"end": 1009
} | public class ____(IServiceProvider serviceProvider) {
public ValidationResult Validate<T>(T request) {
var validator = serviceProvider.GetService<IValidator<T>>();
if (validator is null)
throw new InvalidOperationException($"No validator found for {request!.GetType().Name}");
return validator.Validate(request);
}
public void EnsureGrpcRequestIsValid<T>(T request) {
var result = Validate(request);
if (!result.IsValid)
throw RpcExceptions.InvalidArgument(result);
}
}
| RequestValidationService |
csharp | dotnet__aspnetcore | src/Mvc/Mvc.RazorPages/src/Builder/PageActionEndpointConventionBuilderResourceCollectionExtensions.cs | {
"start": 487,
"end": 2148
} | public static class ____
{
private const string ResourceCollectionResolverKey = "__ResourceCollectionResolver";
/// <summary>
/// Adds a <see cref="ResourceAssetCollection"/> metadata instance to the endpoints.
/// </summary>
/// <param name="builder">The <see cref="PageActionEndpointConventionBuilder"/>.</param>
/// <param name="manifestPath">The manifest associated with the assets.</param>
/// <returns></returns>
public static PageActionEndpointConventionBuilder WithStaticAssets(
this PageActionEndpointConventionBuilder builder,
string? manifestPath = null)
{
ArgumentNullException.ThrowIfNull(builder);
if (builder.Items.TryGetValue(EndpointRouteBuilderKey, out var endpointBuilder))
{
var (resolver, registered) = builder.Items.TryGetValue(ResourceCollectionResolverKey, out var value)
? ((ResourceCollectionResolver)value, true)
: (new ResourceCollectionResolver((IEndpointRouteBuilder)endpointBuilder), false);
resolver.ManifestName = manifestPath;
if (!registered)
{
builder.Items[ResourceCollectionResolverKey] = resolver;
var collection = resolver.ResolveResourceCollection();
var importMap = resolver.ResolveImportMap();
builder.Add(endpointBuilder =>
{
endpointBuilder.Metadata.Add(collection);
endpointBuilder.Metadata.Add(importMap);
});
}
}
return builder;
}
}
| PageActionEndpointConventionBuilderResourceCollectionExtensions |
csharp | dotnetcore__Util | test/Util.Ui.Tests/Samples/Containers/ContainerTagHelper.cs | {
"start": 364,
"end": 705
} | public class ____ : AngularTagHelperBase {
/// <inheritdoc />
protected override IRender GetRender( TagHelperContext context, TagHelperOutput output, TagHelperContent content ) {
var config = new Config( context, output, content );
return new ContainerRender( config );
}
}
} | ContainerTagHelper |
csharp | nopSolutions__nopCommerce | src/Libraries/Nop.Core/Domain/News/NewsItem.cs | {
"start": 178,
"end": 2029
} | public partial class ____ : BaseEntity, ISlugSupported, IStoreMappingSupported, IMetaTagsSupported
{
/// <summary>
/// Gets or sets the language identifier
/// </summary>
public int LanguageId { get; set; }
/// <summary>
/// Gets or sets the news title
/// </summary>
public string Title { get; set; }
/// <summary>
/// Gets or sets the short text
/// </summary>
public string Short { get; set; }
/// <summary>
/// Gets or sets the full text
/// </summary>
public string Full { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the news item is published
/// </summary>
public bool Published { get; set; }
/// <summary>
/// Gets or sets the news item start date and time
/// </summary>
public DateTime? StartDateUtc { get; set; }
/// <summary>
/// Gets or sets the news item end date and time
/// </summary>
public DateTime? EndDateUtc { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the news post comments are allowed
/// </summary>
public bool AllowComments { get; set; }
/// <summary>
/// Gets or sets a value indicating whether the entity is limited/restricted to certain stores
/// </summary>
public bool LimitedToStores { get; set; }
/// <summary>
/// Gets or sets the meta keywords
/// </summary>
public string MetaKeywords { get; set; }
/// <summary>
/// Gets or sets the meta description
/// </summary>
public string MetaDescription { get; set; }
/// <summary>
/// Gets or sets the meta title
/// </summary>
public string MetaTitle { get; set; }
/// <summary>
/// Gets or sets the date and time of entity creation
/// </summary>
public DateTime CreatedOnUtc { get; set; }
} | NewsItem |
csharp | dotnet__maui | src/Controls/tests/Xaml.UnitTests/Issues/Bz28689.xaml.cs | {
"start": 273,
"end": 693
} | class ____
{
[Test]
public void XArrayInResources([Values] XamlInflator inflator)
{
var layout = new Bz28689(inflator);
var array = layout.Resources["stringArray"];
Assert.That(array, Is.TypeOf<string[]>());
var stringarray = (string[])array;
Assert.AreEqual(2, stringarray.Length);
Assert.AreEqual("Test1", stringarray[0]);
Assert.AreEqual("Test2", stringarray[1]);
}
}
}
} | Tests |
csharp | ServiceStack__ServiceStack | ServiceStack/tests/ServiceStack.Common.Tests/ContainerChildTests.cs | {
"start": 339,
"end": 511
} | public class ____
{
public readonly string label;
public Dependency(string label)
{
this.label = label;
}
}
| Dependency |
csharp | dotnet__efcore | src/ef/Json.cs | {
"start": 281,
"end": 799
} | internal static class ____
{
public static CommandOption ConfigureOption(CommandLineApplication command)
=> command.Option("--json", Resources.JsonDescription);
public static string Literal(string? text)
=> text != null
? "\"" + text.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\""
: "null";
public static string Literal(bool? value)
=> value.HasValue
? value.Value
? "true"
: "false"
: "null";
}
| Json |
csharp | RicoSuter__NJsonSchema | src/NJsonSchema.CodeGeneration.CSharp.Tests/ArrayTests.cs | {
"start": 1053,
"end": 1886
} | public class ____
{
[NotNull]
[ItemsCanBeNull]
public List<int?> Items { get; set; }
}
[Fact]
public async Task When_array_item_is_nullable_then_generated_CSharp_is_correct()
{
// Arrange
var schema = NewtonsoftJsonSchemaGenerator.FromType<ClassWithNullableArrayItems>();
var json = schema.ToJson();
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings());
// Act
var output = generator.GenerateFile("MyClass");
// Assert
Assert.True(schema.Properties["Items"].Item.IsNullable(SchemaType.JsonSchema));
await VerifyHelper.Verify(output);
CSharpCompiler.AssertCompile(output);
}
}
} | ClassWithNullableArrayItems |
csharp | JoshClose__CsvHelper | src/CsvHelper/Configuration/ClassMapBuilder.cs | {
"start": 3696,
"end": 3991
} | public interface ____<TClass, TMember> :
IHasMap<TClass>,
IHasTypeConverter<TClass, TMember>,
IHasName<TClass, TMember>,
IHasDefault<TClass, TMember>,
IHasValidate<TClass, TMember>
{ }
/// <summary>
/// Has optional capabilities.
/// </summary>
/// <typeparam name="TClass">The | IHasIndexOptions |
csharp | dotnet__aspnetcore | src/ObjectPool/test/DisposableObjectPoolTest.cs | {
"start": 3121,
"end": 3390
} | private class ____ : IPooledObjectPolicy<List<int>>
{
public List<int> Create()
{
return new List<int>(17);
}
public bool Return(List<int> obj)
{
return obj.Capacity == 17;
}
}
| ListPolicy |
csharp | unoplatform__uno | src/SamplesApp/SamplesApp.UITests/Windows_UI_Xaml_Input/GestureEventsCommons_Tests.cs | {
"start": 295,
"end": 2602
} | public partial class ____ : SampleControlUITestBase
{
[Test]
[AutoRetry]
[ActivePlatforms(Platform.Android)] // Fixed in another commit coming soon
public void When_Tapped_Then_ArgsLocationIsValid()
{
Run("UITests.Shared.Windows_UI_Input.GestureRecognizerTests.GestureEventsCommons");
var root = _app.WaitForElement("WhenTappedThenArgsLocationIsValid_Root").Single();
var target = _app.WaitForElement("WhenTappedThenArgsLocationIsValid_Target").Single();
const int tapX = 10, tapY = 10;
(int x, int y) targetToRoot = ((int)(target.Rect.X - root.Rect.X), (int)(target.Rect.Y - root.Rect.Y));
_app.TapCoordinates(target.Rect.X + tapX, target.Rect.Y + tapY);
var relativeToRoot = _app.Marked("WhenTappedThenArgsLocationIsValid_Result_RelativeToRoot").GetDependencyPropertyValue<string>("Text");
var relativeToTarget = _app.Marked("WhenTappedThenArgsLocationIsValid_Result_RelativeToTarget").GetDependencyPropertyValue<string>("Text");
relativeToTarget.Should().Be($"({tapX:D},{tapY:D})");
relativeToRoot.Should().Be($"({tapX + targetToRoot.x:D},{tapY + targetToRoot.y:D})");
}
[Test]
[AutoRetry]
public void When_ChildHandlesPointers()
{
Run("UITests.Shared.Windows_UI_Input.GestureRecognizerTests.GestureEventsCommons");
var target = _app.WaitForElement("WhenChildHandlesPointers_Target").Single();
const int tapX = 10, tapY = 10;
_app.TapCoordinates(target.Rect.X + tapX, target.Rect.Y + tapY);
var result = _app.Marked("WhenChildHandlesPointers_Result").GetDependencyPropertyValue<string>("Text");
result.Should().Be("Yes");
}
[Test]
[AutoRetry]
public void When_MultipleTappedRecognizer()
{
Run("UITests.Shared.Windows_UI_Input.GestureRecognizerTests.GestureEventsCommons");
var target = _app.WaitForElement("WhenMultipleTappedRecognizer_Target").Single();
const int tapX = 10, tapY = 10;
_app.TapCoordinates(target.Rect.X + tapX, target.Rect.Y + tapY);
var resultParent = _app.Marked("WhenMultipleTappedRecognizer_Result_Parent").GetDependencyPropertyValue<string>("Text");
var resultTarget = _app.Marked("WhenMultipleTappedRecognizer_Result_Target").GetDependencyPropertyValue<string>("Text");
resultParent.Should().Be("1");
resultTarget.Should().Be("1");
}
}
}
| GestureEventsCommons_Tests |
csharp | nunit__nunit | src/NUnitFramework/framework/Interfaces/ResultState.cs | {
"start": 566,
"end": 9095
} | public class ____ : IEquatable<ResultState>
{
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
public ResultState(TestStatus status) : this(status, string.Empty, FailureSite.Test)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="label">The label.</param>
public ResultState(TestStatus status, string? label) : this(status, label, FailureSite.Test)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="site">The stage at which the result was produced</param>
public ResultState(TestStatus status, FailureSite site) : this(status, string.Empty, site)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="label">The label.</param>
/// <param name="site">The stage at which the result was produced</param>
public ResultState(TestStatus status, string? label, FailureSite site)
{
Status = status;
Label = label ?? string.Empty;
Site = site;
}
#endregion
#region Predefined ResultStates
/// <summary>
/// The result is inconclusive
/// </summary>
public static readonly ResultState Inconclusive = new(TestStatus.Inconclusive);
/// <summary>
/// The test has been skipped.
/// </summary>
public static readonly ResultState Skipped = new(TestStatus.Skipped);
/// <summary>
/// The test has been ignored.
/// </summary>
public static readonly ResultState Ignored = new(TestStatus.Skipped, "Ignored");
/// <summary>
/// The test was skipped because it is explicit
/// </summary>
public static readonly ResultState Explicit = new(TestStatus.Skipped, "Explicit");
/// <summary>
/// The test succeeded
/// </summary>
public static readonly ResultState Success = new(TestStatus.Passed);
/// <summary>
/// The test issued a warning
/// </summary>
public static readonly ResultState Warning = new(TestStatus.Warning);
/// <summary>
/// The test failed
/// </summary>
public static readonly ResultState Failure = new(TestStatus.Failed);
/// <summary>
/// The test encountered an unexpected exception
/// </summary>
public static readonly ResultState Error = new(TestStatus.Failed, "Error");
/// <summary>
/// The test was cancelled by the user
/// </summary>
public static readonly ResultState Cancelled = new(TestStatus.Failed, "Cancelled");
/// <summary>
/// The test was not runnable.
/// </summary>
public static readonly ResultState NotRunnable = new(TestStatus.Failed, "Invalid");
/// <summary>
/// A suite failed because one or more child tests failed or had errors
/// </summary>
public static readonly ResultState ChildFailure = Failure.WithSite(FailureSite.Child);
/// <summary>
/// A suite failed because one or more child tests had warnings
/// </summary>
public static readonly ResultState ChildWarning = Warning.WithSite(FailureSite.Child);
/// <summary>
/// A suite is marked ignored because one or more child tests were ignored
/// </summary>
public static readonly ResultState ChildIgnored = Ignored.WithSite(FailureSite.Child);
/// <summary>
/// A suite failed in its OneTimeSetUp
/// </summary>
public static readonly ResultState SetUpFailure = Failure.WithSite(FailureSite.SetUp);
/// <summary>
/// A suite had an unexpected exception in its OneTimeSetUp
/// </summary>
public static readonly ResultState SetUpError = Error.WithSite(FailureSite.SetUp);
/// <summary>
/// A suite had an unexpected exception in its OneTimeDown
/// </summary>
public static readonly ResultState TearDownError = Error.WithSite(FailureSite.TearDown);
#endregion
#region Properties
/// <summary>
/// Gets the TestStatus for the test.
/// </summary>
/// <value>The status.</value>
public TestStatus Status { get; }
/// <summary>
/// Gets the label under which this test result is
/// categorized, or <see cref="string.Empty"/> if none.
/// </summary>
public string Label { get; }
/// <summary>
/// Gets the stage of test execution in which
/// the failure or other result took place.
/// </summary>
public FailureSite Site { get; }
/// <summary>
/// Get a new ResultState, which is the same as the current
/// one but with the FailureSite set to the specified value.
/// </summary>
/// <param name="site">The FailureSite to use</param>
/// <returns>A new ResultState</returns>
public ResultState WithSite(FailureSite site)
{
return new ResultState(Status, Label, site);
}
/// <summary>
/// Test whether this ResultState has the same Status and Label
/// as another one. In other words, the whether two are equal
/// ignoring the Site.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public bool Matches(ResultState other)
{
return Status == other.Status && Label == other.Label;
}
#endregion
#region Equality
/// <summary>Determines whether the specified object is equal to the current object.</summary>
/// <param name="obj">The object to compare with the current object.</param>
public override bool Equals(object? obj)
{
return Equals(obj as ResultState);
}
/// <summary>Indicates whether the current object is equal to another object of the same type.</summary>
/// <param name="other">An object to compare with this object.</param>
public bool Equals(ResultState? other)
{
return other is not null &&
Status == other.Status &&
Label == other.Label &&
Site == other.Site;
}
/// <summary>Serves as the default hash function.</summary>
public override int GetHashCode()
{
var hashCode = -665355758;
hashCode = hashCode * -1521134295 + Status.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Label);
hashCode = hashCode * -1521134295 + Site.GetHashCode();
return hashCode;
}
#endregion
#region Operator Overloads
/// <summary>
/// Overload == operator for ResultStates
/// </summary>
public static bool operator ==(ResultState? left, ResultState? right)
=> left?.Equals(right) ?? right is null;
/// <summary>
/// Overload != operator for ResultStates
/// </summary>
public static bool operator !=(ResultState? left, ResultState? right) => !(left == right);
#endregion
#region ToString Override
/// <summary>
/// Returns a <see cref="string"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="string"/> that represents this instance.
/// </returns>
public override string ToString()
{
var sb = new StringBuilder(Status.ToString());
if (Label.Length > 0)
sb.AppendFormat(":{0}", Label);
if (Site != FailureSite.Test)
sb.AppendFormat("({0})", Site.ToString());
return sb.ToString();
}
#endregion
}
/// <summary>
/// The FailureSite | ResultState |
csharp | bitwarden__server | src/Core/Entities/Transaction.cs | {
"start": 143,
"end": 907
} | public class ____ : ITableObject<Guid>
{
public Guid Id { get; set; }
public Guid? UserId { get; set; }
public Guid? OrganizationId { get; set; }
public TransactionType Type { get; set; }
public decimal Amount { get; set; }
public bool? Refunded { get; set; }
public decimal? RefundedAmount { get; set; }
[MaxLength(100)]
public string? Details { get; set; }
public PaymentMethodType? PaymentMethodType { get; set; }
public GatewayType? Gateway { get; set; }
[MaxLength(50)]
public string? GatewayId { get; set; }
public DateTime CreationDate { get; set; } = DateTime.UtcNow;
public Guid? ProviderId { get; set; }
public void SetNewId()
{
Id = CoreHelpers.GenerateComb();
}
}
| Transaction |
csharp | nunit__nunit | src/NUnitFramework/framework/Constraints/CollectionOrderedConstraint.cs | {
"start": 448,
"end": 864
} | public class ____ : CollectionConstraint
{
private readonly List<OrderingStep> _steps = new();
// The step we are currently building
private OrderingStep _activeStep;
// If not ordered, index where ordering breaks
private int _breakingIndex;
// If not ordered, value on which ordering breaks
private object? _breakingValue;
| CollectionOrderedConstraint |
csharp | dotnet__maui | src/Core/src/Handlers/ScrollView/ScrollViewHandler.Standard.cs | {
"start": 106,
"end": 848
} | public partial class ____ : ViewHandler<IScrollView, object>
{
protected override object CreatePlatformView() => throw new NotImplementedException();
public static void MapContent(IViewHandler handler, IScrollView scrollView) { }
public static void MapHorizontalScrollBarVisibility(IViewHandler handler, IScrollView scrollView) { }
public static void MapVerticalScrollBarVisibility(IViewHandler handler, IScrollView scrollView) { }
public static void MapOrientation(IViewHandler handler, IScrollView scrollView) { }
public static void MapContentSize(IViewHandler handler, IScrollView scrollView) { }
public static void MapRequestScrollTo(IScrollViewHandler handler, IScrollView scrollView, object? args) { }
}
}
| ScrollViewHandler |
csharp | ServiceStack__ServiceStack | ServiceStack.Azure/src/ServiceStack.Azure/Storage/AzureTableCacheClient.cs | {
"start": 9868,
"end": 10688
} | public class ____ : TableEntity
{
public TableCacheEntry(string key)
{
this.PartitionKey = "";
this.RowKey = key;
}
public TableCacheEntry() { }
[StringLength(1024 * 2014 /* 1 MB max */
- 1024 /* partition key max size*/
- 1024 /* row key max size */
- 64 /* timestamp size */
- 64 * 3 /* 3 datetime fields */
// - 8 * 1024 /* ID */
)]
public string? Data { get; set; }
public DateTime? ExpiryDate { get; set; }
public DateTime CreatedDate { get; set; }
public DateTime ModifiedDate { get; set; }
internal bool HasExpired => ExpiryDate != null && ExpiryDate < DateTime.UtcNow;
}
} | TableCacheEntry |
csharp | dotnet__orleans | test/Transactions/Orleans.Transactions.Azure.Test/TestFixture.cs | {
"start": 3194,
"end": 3486
} | public class ____ : TestFixture
{
protected override void ConfigureTestCluster(TestClusterBuilder builder)
{
builder.AddSiloBuilderConfigurator<SkewedClockConfigurator>();
base.ConfigureTestCluster(builder);
}
}
| SkewedClockTestFixture |
csharp | MassTransit__MassTransit | src/Transports/MassTransit.ActiveMqTransport/Topology/IActiveMqSendTopology.cs | {
"start": 60,
"end": 812
} | public interface ____ :
ISendTopology
{
new IActiveMqMessageSendTopologyConfigurator<T> GetMessageTopology<T>()
where T : class;
SendSettings GetSendSettings(ActiveMqEndpointAddress address);
/// <summary>
/// Return the error settings for the queue
/// </summary>
/// <param name="settings"></param>
/// <returns></returns>
ErrorSettings GetErrorSettings(EntitySettings settings);
/// <summary>
/// Return the dead letter settings for the queue
/// </summary>
/// <param name="settings"></param>
/// <returns></returns>
DeadLetterSettings GetDeadLetterSettings(EntitySettings settings);
}
}
| IActiveMqSendTopology |
csharp | dotnet__orleans | src/Orleans.Core/Providers/IGrainStorageSerializer.cs | {
"start": 1024,
"end": 1717
} | public static class ____
{
/// <summary>
/// Deserializes the provided data.
/// </summary>
/// <param name="serializer">The grain state serializer.</param>
/// <param name="input">The data to deserialize.</param>
/// <typeparam name="T">The output type.</typeparam>
/// <returns>The deserialized object.</returns>
public static T Deserialize<T>(this IGrainStorageSerializer serializer, ReadOnlyMemory<byte> input)
=> serializer.Deserialize<T>(new BinaryData(input));
}
/// <summary>
/// Interface to be implemented by the storage provider options.
/// </summary>
| GrainStorageSerializerExtensions |
csharp | ChilliCream__graphql-platform | src/StrawberryShake/CodeGeneration/src/CodeGeneration/Analyzers/Models/EnumTypeModel.cs | {
"start": 355,
"end": 449
} | enum ____.
/// </param>
/// <param name="description">
/// The description of the | type |
csharp | AvaloniaUI__Avalonia | src/Windows/Avalonia.Win32/DirectX/DirectXStructs.cs | {
"start": 3141,
"end": 3335
} | struct ____
{
public uint DirtyRectsCount;
public RECT* pDirtyRects;
public RECT* pScrollRect;
public POINT* pScrollOffset;
}
| DXGI_PRESENT_PARAMETERS |
csharp | unoplatform__uno | src/Uno.UWP/Devices/Sensors/Barometer.iOS.cs | {
"start": 128,
"end": 1091
} | public partial class ____
{
private CMAltimeter? _altimeter;
private static Barometer? TryCreateInstance() => !CMAltimeter.IsRelativeAltitudeAvailable ?
null :
new Barometer();
private void StartReading()
{
_altimeter ??= new();
_altimeter.StartRelativeAltitudeUpdates(new NSOperationQueue(), RelativeAltitudeUpdateReceived);
}
private void StopReading()
{
if (_altimeter == null)
{
return;
}
_altimeter.StopRelativeAltitudeUpdates();
_altimeter.Dispose();
_altimeter = null;
}
private void RelativeAltitudeUpdateReceived(CMAltitudeData data, NSError error)
{
var barometerReading = new BarometerReading(
KPaToHPa(data.Pressure.DoubleValue),
SensorHelpers.TimestampToDateTimeOffset(data.Timestamp));
_readingChangedWrapper.Invoke(
this,
new BarometerReadingChangedEventArgs(barometerReading));
}
private double KPaToHPa(double pressureInKPa) => pressureInKPa * 10;
}
}
| Barometer |
csharp | Xabaril__AspNetCore.Diagnostics.HealthChecks | test/HealthChecks.UI.Tests/Functional/DatabaseProviders/HostBuilderHelper.cs | {
"start": 129,
"end": 1700
} | public class ____
{
public static IWebHostBuilder Create(ManualResetEventSlim hostReset, ManualResetEventSlim? collectorReset = null, Action<HealthChecksUIBuilder>? configureUI = null)
{
return new WebHostBuilder()
.ConfigureServices(services =>
{
var builder = services
.AddRouting()
.AddHealthChecks()
.AddCheck("check1", () => HealthCheckResult.Healthy())
.Services
.AddHealthChecksUI(setup => setup.AddHealthCheckEndpoint(ProviderTestHelper.Endpoints[0].Name, ProviderTestHelper.Endpoints[0].Uri));
configureUI?.Invoke(builder);
if (collectorReset != null)
{
services.AddTransient<IHealthCheckCollectorInterceptor>(sp => new TestCollectorInterceptor(collectorReset));
}
}).Configure(app =>
{
app
.UseRouting()
.UseEndpoints(endpoints =>
{
endpoints.MapHealthChecks("/health", new HealthCheckOptions
{
Predicate = r => true,
ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});
endpoints.MapHealthChecksUI();
});
var lifetime = app.ApplicationServices.GetRequiredService<IHostApplicationLifetime>();
lifetime.ApplicationStarted.Register(() => hostReset.Set());
});
}
}
| HostBuilderHelper |
csharp | aspnetboilerplate__aspnetboilerplate | test/Abp.ZeroCore.SampleApp/Application/AppAuthorizationProvider.cs | {
"start": 121,
"end": 614
} | public class ____ : AuthorizationProvider
{
public override void SetPermissions(IPermissionDefinitionContext context)
{
context.CreatePermission(AppPermissions.TestPermission, AppLocalizationHelper.L("TestPermission"), multiTenancySides: MultiTenancySides.Tenant);
context.CreatePermission("Permission1", new FixedLocalizableString("Permission1"));
context.CreatePermission("Permission2", new FixedLocalizableString("Permission2"));
}
} | AppAuthorizationProvider |
csharp | npgsql__npgsql | test/Npgsql.Tests/CommandTests.cs | {
"start": 40730,
"end": 68923
} | record ____
{
public string A { get; set; } = null!;
public string B { get; set; } = null!;
public string C { get; set; } = null!;
public string D { get; set; } = null!;
public string E { get; set; } = null!;
public string F { get; set; } = null!;
public string G { get; set; } = null!;
public string H { get; set; } = null!;
}
[Test]
public async Task Array_overflow_message_length_throws()
{
// Create a separate dataSource because of Multiplexing (otherwise we can break unrelated queries)
await using var dataSource = CreateDataSource();
await using var conn = await dataSource.OpenConnectionAsync();
var largeString = new string('A', 1 << 29);
await using var cmd = conn.CreateCommand();
cmd.CommandText = "SELECT @a";
var array = new[]
{
largeString,
largeString,
largeString,
largeString,
largeString,
largeString,
largeString,
largeString
};
cmd.Parameters.AddWithValue("a", array);
Assert.ThrowsAsync<OverflowException>(async () => await cmd.ExecuteNonQueryAsync());
}
[Test]
public async Task Range_overflow_message_length_throws()
{
await using var adminConnection = await OpenConnectionAsync();
var type = await GetTempTypeName(adminConnection);
var rangeType = await GetTempTypeName(adminConnection);
await adminConnection.ExecuteNonQueryAsync(
$"CREATE TYPE {type} AS (a text, b text, c text, d text, e text, f text, g text, h text);CREATE TYPE {rangeType} AS RANGE(subtype={type})");
var dataSourceBuilder = CreateDataSourceBuilder();
dataSourceBuilder.MapComposite<BigComposite>(type);
dataSourceBuilder.EnableUnmappedTypes();
await using var dataSource = dataSourceBuilder.Build();
await using var connection = await dataSource.OpenConnectionAsync();
var largeString = new string('A', (1 << 28) + 2000000);
await using var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT @a";
var composite = new BigComposite
{
A = largeString,
B = largeString,
C = largeString,
D = largeString
};
var range = new NpgsqlRange<BigComposite>(composite, composite);
cmd.Parameters.Add(new NpgsqlParameter
{
Value = range,
ParameterName = "a",
DataTypeName = rangeType
});
Assert.ThrowsAsync<OverflowException>(async () => await cmd.ExecuteNonQueryAsync());
}
[Test]
public async Task Multirange_overflow_message_length_throws()
{
await using var adminConnection = await OpenConnectionAsync();
MinimumPgVersion(adminConnection, "14.0", "Multirange types were introduced in PostgreSQL 14");
var type = await GetTempTypeName(adminConnection);
var rangeType = await GetTempTypeName(adminConnection);
await adminConnection.ExecuteNonQueryAsync(
$"CREATE TYPE {type} AS (a text, b text, c text, d text, e text, f text, g text, h text);CREATE TYPE {rangeType} AS RANGE(subtype={type})");
var dataSourceBuilder = CreateDataSourceBuilder();
dataSourceBuilder.MapComposite<BigComposite>(type);
dataSourceBuilder.EnableUnmappedTypes();
await using var dataSource = dataSourceBuilder.Build();
await using var connection = await dataSource.OpenConnectionAsync();
var largeString = new string('A', (1 << 28) + 2000000);
await using var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT @a";
var composite = new BigComposite
{
A = largeString
};
var range = new NpgsqlRange<BigComposite>(composite, composite);
var multirange = new[]
{
range,
range,
range,
range
};
cmd.Parameters.Add(new NpgsqlParameter
{
Value = multirange,
ParameterName = "a",
DataTypeName = rangeType + "_multirange"
});
Assert.ThrowsAsync<OverflowException>(async () => await cmd.ExecuteNonQueryAsync());
}
[Test, Description("CreateCommand before connection open")]
[IssueLink("https://github.com/npgsql/npgsql/issues/565")]
public async Task Create_command_before_connection_open()
{
using var conn = new NpgsqlConnection(ConnectionString);
var cmd = new NpgsqlCommand("SELECT 1", conn);
conn.Open();
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(1));
}
[Test]
public void Connection_not_set_throws()
{
var cmd = new NpgsqlCommand("SELECT 1");
Assert.That(() => cmd.ExecuteScalarAsync(), Throws.Exception.TypeOf<InvalidOperationException>());
}
[Test]
public void Connection_not_open_throws()
{
using var conn = CreateConnection();
var cmd = new NpgsqlCommand("SELECT 1", conn);
Assert.That(() => cmd.ExecuteScalarAsync(), Throws.Exception.TypeOf<InvalidOperationException>());
}
[Test]
public async Task ExecuteNonQuery_Throws_PostgresException([Values] bool async)
{
if (!async && IsMultiplexing)
return;
await using var conn = await OpenConnectionAsync();
var table1 = await CreateTempTable(conn, "id integer PRIMARY key, t varchar(40)");
var table2 = await CreateTempTable(conn, $"id SERIAL primary key, {table1}_id integer references {table1}(id) INITIALLY DEFERRED");
var sql = $"insert into {table2} ({table1}_id) values (1) returning id";
var ex = async
? Assert.ThrowsAsync<PostgresException>(async () => await conn.ExecuteNonQueryAsync(sql))
: Assert.Throws<PostgresException>(() => conn.ExecuteNonQuery(sql));
Assert.That(ex!.SqlState, Is.EqualTo(PostgresErrorCodes.ForeignKeyViolation));
}
[Test]
public async Task ExecuteScalar_Throws_PostgresException([Values] bool async)
{
if (!async && IsMultiplexing)
return;
await using var conn = await OpenConnectionAsync();
var table1 = await CreateTempTable(conn, "id integer PRIMARY key, t varchar(40)");
var table2 = await CreateTempTable(conn, $"id SERIAL primary key, {table1}_id integer references {table1}(id) INITIALLY DEFERRED");
var sql = $"insert into {table2} ({table1}_id) values (1) returning id";
var ex = async
? Assert.ThrowsAsync<PostgresException>(async () => await conn.ExecuteScalarAsync(sql))
: Assert.Throws<PostgresException>(() => conn.ExecuteScalar(sql));
Assert.That(ex!.SqlState, Is.EqualTo(PostgresErrorCodes.ForeignKeyViolation));
}
[Test]
public async Task ExecuteReader_Throws_PostgresException([Values] bool async)
{
if (!async && IsMultiplexing)
return;
await using var conn = await OpenConnectionAsync();
var table1 = await CreateTempTable(conn, "id integer PRIMARY key, t varchar(40)");
var table2 = await CreateTempTable(conn, $"id SERIAL primary key, {table1}_id integer references {table1}(id) INITIALLY DEFERRED");
await using var cmd = conn.CreateCommand();
cmd.CommandText = $"insert into {table2} ({table1}_id) values (1) returning id";
await using var reader = async
? await cmd.ExecuteReaderAsync()
: cmd.ExecuteReader();
Assert.That(async ? await reader.ReadAsync() : reader.Read());
var value = reader.GetInt32(0);
Assert.That(value, Is.EqualTo(1));
Assert.That(async ? await reader.ReadAsync() : reader.Read(), Is.False);
var ex = async
? Assert.ThrowsAsync<PostgresException>(async () => await reader.NextResultAsync())
: Assert.Throws<PostgresException>(() => reader.NextResult());
Assert.That(ex!.SqlState, Is.EqualTo(PostgresErrorCodes.ForeignKeyViolation));
}
[Test]
public void Command_is_recycled([Values] bool allResultTypesAreUnknown)
{
using var conn = OpenConnection();
var cmd1 = conn.CreateCommand();
cmd1.CommandText = "SELECT @p1";
if (allResultTypesAreUnknown)
cmd1.AllResultTypesAreUnknown = true;
else
cmd1.UnknownResultTypeList = [true];
var tx = conn.BeginTransaction();
cmd1.Transaction = tx;
cmd1.Parameters.AddWithValue("p1", 8);
_ = cmd1.ExecuteScalar();
cmd1.Dispose();
var cmd2 = conn.CreateCommand();
Assert.That(cmd2, Is.SameAs(cmd1));
Assert.That(cmd2.CommandText, Is.Empty);
Assert.That(cmd2.CommandType, Is.EqualTo(CommandType.Text));
Assert.That(cmd2.Transaction, Is.Null);
Assert.That(cmd2.Parameters, Is.Empty);
Assert.That(cmd2.AllResultTypesAreUnknown, Is.False);
Assert.That(cmd2.UnknownResultTypeList, Is.Null);
// TODO: Leaving this for now, since it'll be replaced by the new batching API
// Assert.That(cmd2.Statements, Is.Empty);
}
[Test]
public void Command_recycled_resets_CommandType()
{
using var conn = CreateConnection();
var cmd1 = conn.CreateCommand();
cmd1.CommandType = CommandType.StoredProcedure;
cmd1.Dispose();
var cmd2 = conn.CreateCommand();
Assert.That(cmd2.CommandType, Is.EqualTo(CommandType.Text));
}
[Test]
[IssueLink("https://github.com/npgsql/npgsql/issues/831")]
[IssueLink("https://github.com/npgsql/npgsql/issues/2795")]
public async Task Many_parameters([Values(PrepareOrNot.NotPrepared, PrepareOrNot.Prepared)] PrepareOrNot prepare)
{
if (prepare == PrepareOrNot.Prepared && IsMultiplexing)
return;
using var conn = await OpenConnectionAsync();
var table = await CreateTempTable(conn, "some_column INT");
using var cmd = new NpgsqlCommand { Connection = conn };
var sb = new StringBuilder($"INSERT INTO {table} (some_column) VALUES ");
for (var i = 0; i < ushort.MaxValue; i++)
{
var paramName = "p" + i;
cmd.Parameters.Add(new NpgsqlParameter(paramName, 8));
if (i > 0)
sb.Append(", ");
sb.Append($"(@{paramName})");
}
cmd.CommandText = sb.ToString();
if (prepare == PrepareOrNot.Prepared)
cmd.Prepare();
await cmd.ExecuteNonQueryAsync();
}
[Test, Description("Bypasses PostgreSQL's uint16 limitation on the number of parameters")]
[IssueLink("https://github.com/npgsql/npgsql/issues/831")]
[IssueLink("https://github.com/npgsql/npgsql/issues/858")]
[IssueLink("https://github.com/npgsql/npgsql/issues/2703")]
public async Task Too_many_parameters_throws([Values(PrepareOrNot.NotPrepared, PrepareOrNot.Prepared)] PrepareOrNot prepare)
{
if (prepare == PrepareOrNot.Prepared && IsMultiplexing)
return;
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand { Connection = conn };
var sb = new StringBuilder("SOME RANDOM SQL ");
for (var i = 0; i < ushort.MaxValue + 1; i++)
{
var paramName = "p" + i;
cmd.Parameters.Add(new NpgsqlParameter(paramName, 8));
if (i > 0)
sb.Append(", ");
sb.Append('@');
sb.Append(paramName);
}
cmd.CommandText = sb.ToString();
if (prepare == PrepareOrNot.Prepared)
{
Assert.That(() => cmd.Prepare(), Throws.Exception
.InstanceOf<NpgsqlException>()
.With.Message.EqualTo("A statement cannot have more than 65535 parameters"));
}
else
{
Assert.That(() => cmd.ExecuteNonQueryAsync(), Throws.Exception
.InstanceOf<NpgsqlException>()
.With.Message.EqualTo("A statement cannot have more than 65535 parameters"));
}
}
[Test, Description("An individual statement cannot have more than 65535 parameters, but a command can (across multiple statements).")]
[IssueLink("https://github.com/npgsql/npgsql/issues/1199")]
public async Task Many_parameters_across_statements()
{
// Create a command with 1000 statements which have 70 params each
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand { Connection = conn };
var paramIndex = 0;
var sb = new StringBuilder();
for (var statementIndex = 0; statementIndex < 1000; statementIndex++)
{
if (statementIndex > 0)
sb.Append("; ");
sb.Append("SELECT ");
var startIndex = paramIndex;
var endIndex = paramIndex + 70;
for (; paramIndex < endIndex; paramIndex++)
{
var paramName = "p" + paramIndex;
cmd.Parameters.Add(new NpgsqlParameter(paramName, 8));
if (paramIndex > startIndex)
sb.Append(", ");
sb.Append('@');
sb.Append(paramName);
}
}
cmd.CommandText = sb.ToString();
await cmd.ExecuteNonQueryAsync();
}
[Test, Description("Makes sure that Npgsql doesn't attempt to send all data before the user can start reading. That would cause a deadlock.")]
public async Task Batched_big_statements_do_not_deadlock()
{
// We're going to send a large multistatement query that would exhaust both the client's and server's
// send and receive buffers (assume 64k per buffer).
var data = new string('x', 1024);
using var conn = await OpenConnectionAsync();
var sb = new StringBuilder();
for (var i = 0; i < 500; i++)
sb.Append("SELECT @p;");
using var cmd = new NpgsqlCommand(sb.ToString(), conn);
cmd.Parameters.AddWithValue("p", NpgsqlDbType.Text, data);
using var reader = await cmd.ExecuteReaderAsync();
for (var i = 0; i < 500; i++)
{
reader.Read();
Assert.That(reader.GetString(0), Is.EqualTo(data));
reader.NextResult();
}
}
[Test]
public void Batched_small_then_big_statements_do_not_deadlock_in_sync_io()
{
if (IsMultiplexing)
return; // Multiplexing, sync I/O
// This makes sure we switch to async writing for batches, starting from the 2nd statement at the latest.
// Otherwise, a small first first statement followed by a huge big one could cause us to deadlock, as we're stuck
// synchronously sending the 2nd statement while PG is stuck sending the results of the 1st.
using var conn = OpenConnection();
var data = new string('x', 5_000_000);
using var cmd = new NpgsqlCommand("SELECT generate_series(1, 500000); SELECT @p", conn);
cmd.Parameters.AddWithValue("p", NpgsqlDbType.Text, data);
cmd.ExecuteNonQuery();
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1429")]
public async Task Same_command_different_param_values()
{
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand("SELECT @p", conn);
cmd.Parameters.AddWithValue("p", 8);
await cmd.ExecuteNonQueryAsync();
cmd.Parameters[0].Value = 9;
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(9));
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/1429")]
public async Task Same_command_different_param_instances()
{
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand("SELECT @p", conn);
cmd.Parameters.AddWithValue("p", 8);
await cmd.ExecuteNonQueryAsync();
cmd.Parameters.RemoveAt(0);
cmd.Parameters.AddWithValue("p", 9);
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(9));
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/3509"), Ignore("Flaky")]
public async Task Bug3509()
{
if (IsMultiplexing)
return;
var csb = new NpgsqlConnectionStringBuilder(ConnectionString)
{
KeepAlive = 1,
};
await using var postmasterMock = PgPostmasterMock.Start(csb.ToString());
await using var dataSource = CreateDataSource(postmasterMock.ConnectionString);
await using var conn = await dataSource.OpenConnectionAsync();
var serverMock = await postmasterMock.WaitForServerConnection();
// Wait for a keepalive to arrive at the server, reply with an error
await serverMock.WaitForData();
var queryTask = Task.Run(async () => await conn.ExecuteNonQueryAsync("SELECT 1"));
// TODO: kind of flaky - think of the way to rewrite
// giving a queryTask some time to get stuck on a lock
await Task.Delay(300);
await serverMock
.WriteErrorResponse("42")
.WriteReadyForQuery()
.FlushAsync();
await serverMock
.WriteScalarResponseAndFlush(1);
var ex = Assert.ThrowsAsync<NpgsqlException>(async () => await queryTask)!;
Assert.That(ex.InnerException, Is.TypeOf<NpgsqlException>()
.With.InnerException.TypeOf<PostgresException>());
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/4134")]
public async Task Cached_command_double_dispose()
{
await using var conn = await OpenConnectionAsync();
var cmd1 = conn.CreateCommand();
cmd1.Dispose();
cmd1.Dispose();
var cmd2 = conn.CreateCommand();
Assert.That(cmd2, Is.SameAs(cmd1));
cmd2.CommandText = "SELECT 1";
Assert.That(await cmd2.ExecuteScalarAsync(), Is.EqualTo(1));
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/4330")]
public async Task Prepare_with_positional_placeholders_after_named()
{
if (IsMultiplexing)
return; // Explicit preparation
await using var conn = await OpenConnectionAsync();
await using var command = new NpgsqlCommand("SELECT @p", conn);
command.Parameters.AddWithValue("p", 10);
await command.ExecuteNonQueryAsync();
command.Parameters.Clear();
command.CommandText = "SELECT $1";
command.Parameters.Add(new() { NpgsqlDbType = NpgsqlDbType.Integer });
Assert.DoesNotThrowAsync(() => command.PrepareAsync());
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/4621")]
[Description("Most of 08* errors are coming whenever there was an error while connecting to a remote server from a cluster, so the connection to the cluster is still OK")]
public async Task Postgres_connection_errors_not_break_connection()
{
if (IsMultiplexing)
return;
await using var postmasterMock = PgPostmasterMock.Start(ConnectionString);
await using var dataSource = CreateDataSource(postmasterMock.ConnectionString);
await using var conn = await dataSource.OpenConnectionAsync();
await using var cmd = conn.CreateCommand();
cmd.CommandText = "SELECT 1";
var queryTask = cmd.ExecuteNonQueryAsync();
var server = await postmasterMock.WaitForServerConnection();
await server
.WriteErrorResponse(PostgresErrorCodes.SqlClientUnableToEstablishSqlConnection)
.WriteReadyForQuery()
.FlushAsync();
var ex = Assert.ThrowsAsync<PostgresException>(async () => await queryTask)!;
Assert.That(ex.SqlState, Is.EqualTo(PostgresErrorCodes.SqlClientUnableToEstablishSqlConnection));
Assert.That(conn.FullState, Is.EqualTo(ConnectionState.Open));
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/4804")]
[Description("Concurrent write and read failure can lead to deadlocks while cleaning up the connector.")]
public async Task Concurrent_read_write_failure_deadlock()
{
if (IsMultiplexing)
return;
await using var postmasterMock = PgPostmasterMock.Start(ConnectionString);
await using var dataSource = CreateDataSource(postmasterMock.ConnectionString);
await using var conn = await dataSource.OpenConnectionAsync();
await using var cmd = conn.CreateCommand();
// Attempt to send a big enough query to fill buffers
// That way the write side should be stuck, waiting for the server to empty buffers
cmd.CommandText = new string('a', 8_000_000);
var queryTask = cmd.ExecuteNonQueryAsync();
var server = await postmasterMock.WaitForServerConnection();
server.Close();
Assert.ThrowsAsync<NpgsqlException>(async () => await queryTask);
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/4906")]
[Description("Make sure we don't cancel a prepended query (and do not deadlock in case of a failure)")]
[Explicit("Flaky due to #5033")]
public async Task Not_cancel_prepended_query([Values] bool failPrependedQuery)
{
if (IsMultiplexing)
return;
await using var postmasterMock = PgPostmasterMock.Start(ConnectionString);
var csb = new NpgsqlConnectionStringBuilder(postmasterMock.ConnectionString)
{
NoResetOnClose = false
};
await using var dataSource = CreateDataSource(csb.ConnectionString);
await using var conn = await dataSource.OpenConnectionAsync();
// reopen connection to append prepended query
await conn.CloseAsync();
await conn.OpenAsync();
using var cts = new CancellationTokenSource();
var queryTask = conn.ExecuteNonQueryAsync("SELECT 1", cancellationToken: cts.Token);
var server = await postmasterMock.WaitForServerConnection();
await server.ExpectSimpleQuery("DISCARD ALL");
await server.ExpectExtendedQuery();
var cancelTask = Task.Run(cts.Cancel);
var cancellationRequestTask = postmasterMock.WaitForCancellationRequest().AsTask();
// Give 1 second to make sure we didn't send cancellation request
await Task.Delay(1000);
Assert.That(cancelTask.IsCompleted, Is.False);
Assert.That(cancellationRequestTask.IsCompleted, Is.False);
if (failPrependedQuery)
{
await server
.WriteErrorResponse(PostgresErrorCodes.SyntaxError)
.WriteReadyForQuery()
.FlushAsync();
await cancelTask;
await cancellationRequestTask;
Assert.ThrowsAsync<PostgresException>(async () => await queryTask);
Assert.That(conn.State, Is.EqualTo(ConnectionState.Closed));
return;
}
await server
.WriteCommandComplete()
.WriteReadyForQuery()
.FlushAsync();
await cancelTask;
await cancellationRequestTask;
await server
.WriteErrorResponse(PostgresErrorCodes.QueryCanceled)
.WriteReadyForQuery()
.FlushAsync();
Assert.ThrowsAsync<OperationCanceledException>(async () => await queryTask);
queryTask = conn.ExecuteNonQueryAsync("SELECT 1");
await server.ExpectExtendedQuery();
await server
.WriteParseComplete()
.WriteBindComplete()
.WriteNoData()
.WriteCommandComplete()
.WriteReadyForQuery()
.FlushAsync();
await queryTask;
}
[Test]
public async Task Cancel_while_reading_from_long_running_query()
{
if (IsMultiplexing)
return;
await using var conn = await OpenConnectionAsync();
await using var cmd = conn.CreateCommand();
cmd.CommandText = """
SELECT *, CASE WHEN "t"."i" = 50000 THEN pg_sleep(100) ELSE NULL END
FROM
(
SELECT generate_series(1, 1000000) AS "i"
) AS "t"
""";
using (var cts = new CancellationTokenSource())
await using (var reader = await cmd.ExecuteReaderAsync(cts.Token))
{
Assert.ThrowsAsync<OperationCanceledException>(async () =>
{
var i = 0;
while (await reader.ReadAsync(cts.Token))
{
i++;
if (i == 10)
cts.Cancel();
}
});
}
cmd.CommandText = "SELECT 42";
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(42));
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/5218")]
[Description("Make sure we do not lose unread messages after resetting oversize buffer")]
public async Task Oversize_buffer_lost_messages()
{
if (IsMultiplexing)
return;
var csb = new NpgsqlConnectionStringBuilder(ConnectionString)
{
NoResetOnClose = true
};
await using var mock = PgPostmasterMock.Start(csb.ConnectionString);
await using var dataSource = CreateDataSource(mock.ConnectionString);
await using var connection = await dataSource.OpenConnectionAsync();
var connector = connection.Connector!;
var server = await mock.WaitForServerConnection();
await server
.WriteParseComplete()
.WriteBindComplete()
.WriteRowDescription(new FieldDescription(TextOid))
.WriteDataRowWithFlush(Encoding.ASCII.GetBytes(new string('a', connection.Settings.ReadBufferSize * 2)));
// Just to make sure we have enough space
await server.FlushAsync();
await server
.WriteDataRow(Encoding.ASCII.GetBytes("abc"))
.WriteCommandComplete()
.WriteReadyForQuery()
.WriteParameterStatus("SomeKey", "SomeValue")
.FlushAsync();
await using var cmd = connection.CreateCommand();
cmd.CommandText = "SELECT 1";
await using (await cmd.ExecuteReaderAsync()) { }
await connection.CloseAsync();
await connection.OpenAsync();
Assert.That(connection.Connector, Is.SameAs(connector));
// We'll get new value after the next query reads ParameterStatus from the buffer
Assert.That(connection.PostgresParameters, Does.Not.ContainKey("SomeKey").WithValue("SomeValue"));
await server
.WriteParseComplete()
.WriteBindComplete()
.WriteRowDescription(new FieldDescription(TextOid))
.WriteDataRow(Encoding.ASCII.GetBytes("abc"))
.WriteCommandComplete()
.WriteReadyForQuery()
.FlushAsync();
await cmd.ExecuteNonQueryAsync();
Assert.That(connection.PostgresParameters, Contains.Key("SomeKey").WithValue("SomeValue"));
}
[Test]
public async Task Completed_transaction_throws([Values] bool commit)
{
await using var conn = await OpenConnectionAsync();
await using var tx = await conn.BeginTransactionAsync();
await using var cmd = conn.CreateCommand();
if (commit)
await tx.CommitAsync();
else
await tx.RollbackAsync();
Assert.Throws<InvalidOperationException>(() => cmd.Transaction = tx);
}
[Test, Description("Writing to properties of a disposed command raises ObjectDisposedException.")]
public async Task Disposed_command_throws_on_assignment()
{
await using var conn = await OpenConnectionAsync();
var command = new NpgsqlCommand("SELECT 1");
command.Dispose();
Assert.Throws<ObjectDisposedException>(() => command.Connection = conn);
Assert.Throws<ObjectDisposedException>(() => command.CommandText = "SELECT 2");
Assert.That(command.Connection, Is.Null);
Assert.That(command.CommandText, Is.EqualTo("SELECT 1"));
}
}
| BigComposite |
csharp | graphql-dotnet__graphql-dotnet | src/GraphQL/Validation/Variables.cs | {
"start": 269,
"end": 2360
} | public class ____ : IEnumerable<Variable>
{
private List<Variable>? _variables;
/// <summary>
/// Initializes a new instance.
/// </summary>
public Variables()
{
}
internal Variables(int initialCount)
{
_variables = new List<Variable>(initialCount);
}
/// <summary>
/// Adds a variable to the list.
/// </summary>
public virtual void Add(Variable variable) => (_variables ??= []).Add(variable ?? throw new ArgumentNullException(nameof(variable)));
/// <summary>
/// Returns the first variable with a matching name, or <paramref name="defaultValue"/> if none are found.
/// </summary>
public object? ValueFor(string name, object? defaultValue = null)
{
return ValueFor(name, out var value) ? value.Value : defaultValue;
}
/// <summary>
/// Gets the first variable with a matching name.
/// </summary>
public Variable? Find(ROM name)
{
if (_variables != null)
{
foreach (var v in _variables)
{
if (v.Name == name)
{
return v;
}
}
}
return null;
}
/// <summary>
/// Gets the first variable with a matching name. Returns <see langword="true"/> if a match is found.
/// </summary>
public bool ValueFor(ROM name, out ArgumentValue value)
{
var v = Find(name);
if (v != null)
{
value = new ArgumentValue(v.Value, v.IsDefault || !v.ValueSpecified ? ArgumentSource.VariableDefault : ArgumentSource.Variable);
return v.ValueSpecified;
}
value = default;
return false;
}
/// <inheritdoc/>
public IEnumerator<Variable> GetEnumerator() => (_variables ?? Enumerable.Empty<Variable>()).GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
/// <summary>
/// Returns a static instance that holds no variables.
/// </summary>
public static Variables None { get; } = new NoVariables();
| Variables |
csharp | dotnet__aspnetcore | src/ProjectTemplates/Web.ProjectTemplates/content/BlazorWeb-CSharp/BlazorWebCSharp.1/Components/Account/IdentityComponentsEndpointRouteBuilderExtensions.cs | {
"start": 524,
"end": 6818
} | internal static class ____
{
// These endpoints are required by the Identity Razor components defined in the /Components/Account/Pages directory of this project.
public static IEndpointConventionBuilder MapAdditionalIdentityEndpoints(this IEndpointRouteBuilder endpoints)
{
ArgumentNullException.ThrowIfNull(endpoints);
var accountGroup = endpoints.MapGroup("/Account");
accountGroup.MapPost("/PerformExternalLogin", (
HttpContext context,
[FromServices] SignInManager<ApplicationUser> signInManager,
[FromForm] string provider,
[FromForm] string returnUrl) =>
{
IEnumerable<KeyValuePair<string, StringValues>> query = [
new("ReturnUrl", returnUrl),
new("Action", ExternalLogin.LoginCallbackAction)];
var redirectUrl = UriHelper.BuildRelative(
context.Request.PathBase,
"/Account/ExternalLogin",
QueryString.Create(query));
var properties = signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
return TypedResults.Challenge(properties, [provider]);
});
accountGroup.MapPost("/Logout", async (
ClaimsPrincipal user,
[FromServices] SignInManager<ApplicationUser> signInManager,
[FromForm] string returnUrl) =>
{
await signInManager.SignOutAsync();
return TypedResults.LocalRedirect($"~/{returnUrl}");
});
accountGroup.MapPost("/PasskeyCreationOptions", async (
HttpContext context,
[FromServices] UserManager<ApplicationUser> userManager,
[FromServices] SignInManager<ApplicationUser> signInManager,
[FromServices] IAntiforgery antiforgery) =>
{
await antiforgery.ValidateRequestAsync(context);
var user = await userManager.GetUserAsync(context.User);
if (user is null)
{
return Results.NotFound($"Unable to load user with ID '{userManager.GetUserId(context.User)}'.");
}
var userId = await userManager.GetUserIdAsync(user);
var userName = await userManager.GetUserNameAsync(user) ?? "User";
var optionsJson = await signInManager.MakePasskeyCreationOptionsAsync(new()
{
Id = userId,
Name = userName,
DisplayName = userName
});
return TypedResults.Content(optionsJson, contentType: "application/json");
});
accountGroup.MapPost("/PasskeyRequestOptions", async (
HttpContext context,
[FromServices] UserManager<ApplicationUser> userManager,
[FromServices] SignInManager<ApplicationUser> signInManager,
[FromServices] IAntiforgery antiforgery,
[FromQuery] string? username) =>
{
await antiforgery.ValidateRequestAsync(context);
var user = string.IsNullOrEmpty(username) ? null : await userManager.FindByNameAsync(username);
var optionsJson = await signInManager.MakePasskeyRequestOptionsAsync(user);
return TypedResults.Content(optionsJson, contentType: "application/json");
});
var manageGroup = accountGroup.MapGroup("/Manage").RequireAuthorization();
manageGroup.MapPost("/LinkExternalLogin", async (
HttpContext context,
[FromServices] SignInManager<ApplicationUser> signInManager,
[FromForm] string provider) =>
{
// Clear the existing external cookie to ensure a clean login process
await context.SignOutAsync(IdentityConstants.ExternalScheme);
var redirectUrl = UriHelper.BuildRelative(
context.Request.PathBase,
"/Account/Manage/ExternalLogins",
QueryString.Create("Action", ExternalLogins.LinkLoginCallbackAction));
var properties = signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl, signInManager.UserManager.GetUserId(context.User));
return TypedResults.Challenge(properties, [provider]);
});
var loggerFactory = endpoints.ServiceProvider.GetRequiredService<ILoggerFactory>();
var downloadLogger = loggerFactory.CreateLogger("DownloadPersonalData");
manageGroup.MapPost("/DownloadPersonalData", async (
HttpContext context,
[FromServices] UserManager<ApplicationUser> userManager,
[FromServices] AuthenticationStateProvider authenticationStateProvider) =>
{
var user = await userManager.GetUserAsync(context.User);
if (user is null)
{
return Results.NotFound($"Unable to load user with ID '{userManager.GetUserId(context.User)}'.");
}
var userId = await userManager.GetUserIdAsync(user);
downloadLogger.LogInformation("User with ID '{UserId}' asked for their personal data.", userId);
// Only include personal data for download
var personalData = new Dictionary<string, string>();
var personalDataProps = typeof(ApplicationUser).GetProperties().Where(
prop => Attribute.IsDefined(prop, typeof(PersonalDataAttribute)));
foreach (var p in personalDataProps)
{
personalData.Add(p.Name, p.GetValue(user)?.ToString() ?? "null");
}
var logins = await userManager.GetLoginsAsync(user);
foreach (var l in logins)
{
personalData.Add($"{l.LoginProvider} external login provider key", l.ProviderKey);
}
personalData.Add("Authenticator Key", (await userManager.GetAuthenticatorKeyAsync(user))!);
var fileBytes = JsonSerializer.SerializeToUtf8Bytes(personalData);
context.Response.Headers.TryAdd("Content-Disposition", "attachment; filename=PersonalData.json");
return TypedResults.File(fileBytes, contentType: "application/json", fileDownloadName: "PersonalData.json");
});
return accountGroup;
}
}
| IdentityComponentsEndpointRouteBuilderExtensions |
csharp | ChilliCream__graphql-platform | src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/FusionEnumTypeDefinition.cs | {
"start": 1660,
"end": 1909
} | enum ____.
/// </summary>
public string? Description { get; }
/// <summary>
/// Gets the kind of this type.
/// </summary>
public TypeKind Kind => TypeKind.Enum;
/// <summary>
/// Gets the schema coordinate of this | type |
csharp | CommunityToolkit__Maui | src/CommunityToolkit.Maui/Behaviors/PlatformBehaviors/SelectAllText/SelectAllTextBehavior.macios.cs | {
"start": 195,
"end": 2510
} | public class ____ : BasePlatformBehavior<InputView>
{
/// <inheritdoc/>
protected override void OnAttachedTo(InputView bindable, UIView platformView)
{
base.OnAttachedTo(bindable, platformView);
ApplyBehaviorToControl(true, bindable, platformView);
}
/// <inheritdoc/>
protected override void OnDetachedFrom(InputView bindable, UIView platformView)
{
base.OnDetachedFrom(bindable, platformView);
ApplyBehaviorToControl(false, bindable, platformView);
}
static void ApplyBehaviorToControl<T>(bool apply, InputView inputView, T platformView) where T : UIView
{
switch (inputView, platformView)
{
case (_, UITextField textField):
ApplyToTextField(textField, apply);
break;
case (Editor editor, UITextView uiTextView):
ApplyToTextView(editor, uiTextView, apply);
break;
default:
throw new NotSupportedException($"Control of type: {platformView.GetType().Name} is not supported by this effect.");
}
}
static void ApplyToTextField(UITextField textField, bool shouldApply)
{
if (textField is null)
{
throw new InvalidOperationException("The Platform View can't be null.");
}
if (shouldApply)
{
textField.EditingDidBegin += OnEditingDidBegin;
}
else
{
textField.EditingDidBegin -= OnEditingDidBegin;
}
static void OnEditingDidBegin(object? sender, EventArgs e)
{
if (sender is not UITextField textfield)
{
throw new InvalidOperationException($"The Platform View should be of the type {nameof(UITextField)}.");
}
textfield.PerformSelector(new Selector("selectAll"), null, 0.0f);
}
}
// MacCatalyst support blocked: https://github.com/xamarin/xamarin-macios/issues/15156
static void ApplyToTextView(VisualElement mauiControl, UITextView textView, bool shouldApply)
{
if (OperatingSystem.IsMacCatalyst())
{
Trace.WriteLine($"WARNING: {nameof(SelectAllTextBehavior)} does not support {typeof(Editor).FullName} on MacCatalyst. For more information, see https://github.com/CommunityToolkit/Maui/issues/432");
}
if (shouldApply)
{
mauiControl.Focused += OnTextViewFocussed;
}
else
{
mauiControl.Focused -= OnTextViewFocussed;
}
void OnTextViewFocussed(object? sender, FocusEventArgs e)
{
if (e.IsFocused)
{
textView.SelectAll(textView);
}
}
}
} | SelectAllTextBehavior |
csharp | dotnet__maui | src/Core/src/Platform/Windows/RoutedEventArgsExtensions.cs | {
"start": 233,
"end": 1602
} | internal static class ____
{
public static void SetHandled(this RoutedEventArgs e, bool value)
{
if (e is RightTappedRoutedEventArgs rt)
rt.Handled = value;
else if (e is TappedRoutedEventArgs t)
t.Handled = value;
else if (e is DoubleTappedRoutedEventArgs dt)
dt.Handled = value;
}
public static WPoint? GetPositionRelativeToElement(this RoutedEventArgs e, IElement? relativeTo)
{
if (relativeTo == null)
return GetPositionRelativeToPlatformElement(e, null);
if (relativeTo?.Handler?.PlatformView is UIElement element)
return GetPositionRelativeToPlatformElement(e, element);
return null;
}
public static WPoint? GetPositionRelativeToPlatformElement(this RoutedEventArgs e, UIElement? relativeTo)
{
if (e is RightTappedRoutedEventArgs rt)
return rt.GetPosition(relativeTo);
else if (e is TappedRoutedEventArgs t)
return t.GetPosition(relativeTo);
else if (e is DoubleTappedRoutedEventArgs dt)
return dt.GetPosition(relativeTo);
else if (e is DragStartingEventArgs ds)
return ds.GetPosition(relativeTo);
else if (e is DragEventArgs d)
return d.GetPosition(relativeTo);
else if (e is PointerRoutedEventArgs p)
{
var point = p.GetCurrentPoint(relativeTo);
return new WPoint(point.Position.X, point.Position.Y);
}
return null;
}
}
}
| RoutedEventArgsExtensions |
csharp | EventStore__EventStore | src/KurrentDB.LogV3/Raw.cs | {
"start": 8253,
"end": 8357
} | public enum ____ : byte {
Prepare = 0,
Committed = 1,
Failed = 2,
Removed = 3
}
| TransactionStatus |
csharp | microsoft__semantic-kernel | dotnet/src/SemanticKernel.Core/Memory/Mem0/Mem0Client.cs | {
"start": 4495,
"end": 4985
} | internal sealed class ____
{
[JsonPropertyName("app_id")]
public string? AppId { get; set; }
[JsonPropertyName("agent_id")]
public string? AgentId { get; set; }
[JsonPropertyName("run_id")]
public string? RunId { get; set; }
[JsonPropertyName("user_id")]
public string? UserId { get; set; }
[JsonPropertyName("messages")]
public CreateMemoryMessage[] Messages { get; set; } = [];
}
| CreateMemoryRequest |
csharp | dotnet__aspnetcore | src/Mvc/perf/benchmarkapps/BasicApi/Migrations/BasicApiContextModelSnapshot.cs | {
"start": 313,
"end": 7981
} | partial class ____ : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.SerialColumn)
.HasAnnotation("ProductVersion", "2.1.0-rtm-30799")
.HasAnnotation("Relational:MaxIdentifierLength", 63)
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
modelBuilder.Entity("BasicApi.Models.Category", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<string>("Name");
b.HasKey("Id");
b.ToTable("Categories");
b.HasData(
new { Id = -1, Name = "Dogs" },
new { Id = -2, Name = "Cats" },
new { Id = -3, Name = "Rabbits" },
new { Id = -4, Name = "Lions" }
);
});
modelBuilder.Entity("BasicApi.Models.Image", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<int?>("PetId");
b.Property<string>("Url");
b.HasKey("Id");
b.HasIndex("PetId");
b.ToTable("Images");
b.HasData(
new { Id = -1, PetId = -1, Url = "http://example.com/pets/-1_1.png" },
new { Id = -2, PetId = -2, Url = "http://example.com/pets/-2_1.png" },
new { Id = -3, PetId = -3, Url = "http://example.com/pets/-3_1.png" },
new { Id = -4, PetId = -4, Url = "http://example.com/pets/-4_1.png" },
new { Id = -5, PetId = -5, Url = "http://example.com/pets/-5_1.png" },
new { Id = -6, PetId = -6, Url = "http://example.com/pets/-6_1.png" },
new { Id = -7, PetId = -7, Url = "http://example.com/pets/-7_1.png" },
new { Id = -8, PetId = -8, Url = "http://example.com/pets/-8_1.png" },
new { Id = -9, PetId = -9, Url = "http://example.com/pets/-9_1.png" },
new { Id = -10, PetId = -10, Url = "http://example.com/pets/-10_1.png" },
new { Id = -11, PetId = -11, Url = "http://example.com/pets/-11_1.png" },
new { Id = -12, PetId = -12, Url = "http://example.com/pets/-12_1.png" }
);
});
modelBuilder.Entity("BasicApi.Models.Pet", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<int>("Age");
b.Property<int?>("CategoryId");
b.Property<bool>("HasVaccinations");
b.Property<string>("Name")
.IsRequired()
.HasMaxLength(50);
b.Property<string>("Status")
.IsRequired();
b.HasKey("Id");
b.HasIndex("CategoryId");
b.ToTable("Pets");
b.HasData(
new { Id = -1, Age = 1, CategoryId = -1, HasVaccinations = true, Name = "Dogs1", Status = "available" },
new { Id = -2, Age = 1, CategoryId = -1, HasVaccinations = true, Name = "Dogs2", Status = "available" },
new { Id = -3, Age = 1, CategoryId = -1, HasVaccinations = true, Name = "Dogs3", Status = "available" },
new { Id = -4, Age = 1, CategoryId = -2, HasVaccinations = true, Name = "Cats1", Status = "available" },
new { Id = -5, Age = 1, CategoryId = -2, HasVaccinations = true, Name = "Cats2", Status = "available" },
new { Id = -6, Age = 1, CategoryId = -2, HasVaccinations = true, Name = "Cats3", Status = "available" },
new { Id = -7, Age = 1, CategoryId = -3, HasVaccinations = true, Name = "Rabbits1", Status = "available" },
new { Id = -8, Age = 1, CategoryId = -3, HasVaccinations = true, Name = "Rabbits2", Status = "available" },
new { Id = -9, Age = 1, CategoryId = -3, HasVaccinations = true, Name = "Rabbits3", Status = "available" },
new { Id = -10, Age = 1, CategoryId = -4, HasVaccinations = true, Name = "Lions1", Status = "available" },
new { Id = -11, Age = 1, CategoryId = -4, HasVaccinations = true, Name = "Lions2", Status = "available" },
new { Id = -12, Age = 1, CategoryId = -4, HasVaccinations = true, Name = "Lions3", Status = "available" }
);
});
modelBuilder.Entity("BasicApi.Models.Tag", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
b.Property<string>("Name");
b.Property<int?>("PetId");
b.HasKey("Id");
b.HasIndex("PetId");
b.ToTable("Tags");
b.HasData(
new { Id = -1, Name = "Tag1", PetId = -1 },
new { Id = -2, Name = "Tag1", PetId = -2 },
new { Id = -3, Name = "Tag1", PetId = -3 },
new { Id = -4, Name = "Tag1", PetId = -4 },
new { Id = -5, Name = "Tag1", PetId = -5 },
new { Id = -6, Name = "Tag1", PetId = -6 },
new { Id = -7, Name = "Tag1", PetId = -7 },
new { Id = -8, Name = "Tag1", PetId = -8 },
new { Id = -9, Name = "Tag1", PetId = -9 },
new { Id = -10, Name = "Tag1", PetId = -10 },
new { Id = -11, Name = "Tag1", PetId = -11 },
new { Id = -12, Name = "Tag1", PetId = -12 }
);
});
modelBuilder.Entity("BasicApi.Models.Image", b =>
{
b.HasOne("BasicApi.Models.Pet")
.WithMany("Images")
.HasForeignKey("PetId");
});
modelBuilder.Entity("BasicApi.Models.Pet", b =>
{
b.HasOne("BasicApi.Models.Category", "Category")
.WithMany()
.HasForeignKey("CategoryId");
});
modelBuilder.Entity("BasicApi.Models.Tag", b =>
{
b.HasOne("BasicApi.Models.Pet")
.WithMany("Tags")
.HasForeignKey("PetId");
});
#pragma warning restore 612, 618
}
}
}
| BasicApiContextModelSnapshot |
csharp | dotnet__aspire | src/Aspire.Cli/Projects/ProjectUpdater.cs | {
"start": 41468,
"end": 41896
} | internal record ____(
string Description,
Func<Task> Callback,
string PackageId,
string CurrentVersion,
string NewVersion,
FileInfo ProjectFile) : UpdateStep(Description, Callback)
{
public override string GetFormattedDisplayText()
{
return $"[bold yellow]{PackageId}[/] [bold green]{CurrentVersion.EscapeMarkup()}[/] to [bold green]{NewVersion.EscapeMarkup()}[/]";
}
}
| PackageUpdateStep |
csharp | dotnet__aspnetcore | src/Mvc/Mvc.Razor.RuntimeCompilation/test/FileProviderRazorProjectFileSystemTest.cs | {
"start": 327,
"end": 10583
} | public class ____
{
[Fact]
public void EnumerateFiles_ReturnsEmptySequenceIfNoCshtmlFilesArePresent()
{
// Arrange
var fileProvider = new TestFileProvider("BasePath");
var file1 = fileProvider.AddFile("/File1.txt", "content");
var file2 = fileProvider.AddFile("/File2.js", "content");
fileProvider.AddDirectoryContent("/", new IFileInfo[] { file1, file2 });
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var razorFiles = fileSystem.EnumerateItems("/");
// Assert
Assert.Empty(razorFiles);
}
[Fact]
public void EnumerateFiles_ReturnsCshtmlFiles()
{
// Arrange
var fileProvider = new TestFileProvider("BasePath");
var file1 = fileProvider.AddFile("/File1.cshtml", "content");
var file2 = fileProvider.AddFile("/File2.js", "content");
var file3 = fileProvider.AddFile("/File3.cshtml", "content");
fileProvider.AddDirectoryContent("/", new IFileInfo[] { file1, file2, file3 });
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var razorFiles = fileSystem.EnumerateItems("/");
// Assert
Assert.Collection(
razorFiles.OrderBy(f => f.FilePath),
file =>
{
Assert.Equal("/File1.cshtml", file.FilePath);
Assert.Equal("/", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "File1.cshtml"), file.PhysicalPath);
Assert.Equal("File1.cshtml", file.RelativePhysicalPath);
},
file =>
{
Assert.Equal("/File3.cshtml", file.FilePath);
Assert.Equal("/", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "File3.cshtml"), file.PhysicalPath);
Assert.Equal("File3.cshtml", file.RelativePhysicalPath);
});
}
[Fact]
public void EnumerateFiles_IteratesOverAllCshtmlUnderRoot()
{
// Arrange
var fileProvider = new TestFileProvider("BasePath");
var directory1 = new TestDirectoryFileInfo
{
Name = "Level1-Dir1",
};
var file1 = fileProvider.AddFile("File1.cshtml", "content");
var directory2 = new TestDirectoryFileInfo
{
Name = "Level1-Dir2",
};
fileProvider.AddDirectoryContent("/", new IFileInfo[] { directory1, file1, directory2 });
var file2 = fileProvider.AddFile("/Level1-Dir1/File2.cshtml", "content");
var file3 = fileProvider.AddFile("/Level1-Dir1/File3.cshtml", "content");
var file4 = fileProvider.AddFile("/Level1-Dir1/File4.txt", "content");
var directory3 = new TestDirectoryFileInfo
{
Name = "Level2-Dir1"
};
fileProvider.AddDirectoryContent("/Level1-Dir1", new IFileInfo[] { file2, directory3, file3, file4 });
var file5 = fileProvider.AddFile(Path.Combine("Level1-Dir2", "File5.cshtml"), "content");
fileProvider.AddDirectoryContent("/Level1-Dir2", new IFileInfo[] { file5 });
fileProvider.AddDirectoryContent("/Level1/Level2", new IFileInfo[0]);
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var razorFiles = fileSystem.EnumerateItems("/");
// Assert
Assert.Collection(razorFiles.OrderBy(f => f.FilePath),
file =>
{
Assert.Equal("/File1.cshtml", file.FilePath);
Assert.Equal("/", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "File1.cshtml"), file.PhysicalPath);
Assert.Equal("File1.cshtml", file.RelativePhysicalPath);
},
file =>
{
Assert.Equal("/Level1-Dir1/File2.cshtml", file.FilePath);
Assert.Equal("/", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "Level1-Dir1", "File2.cshtml"), file.PhysicalPath);
Assert.Equal(Path.Combine("Level1-Dir1", "File2.cshtml"), file.RelativePhysicalPath);
},
file =>
{
Assert.Equal("/Level1-Dir1/File3.cshtml", file.FilePath);
Assert.Equal("/", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "Level1-Dir1", "File3.cshtml"), file.PhysicalPath);
Assert.Equal(Path.Combine("Level1-Dir1", "File3.cshtml"), file.RelativePhysicalPath);
},
file =>
{
Assert.Equal("/Level1-Dir2/File5.cshtml", file.FilePath);
Assert.Equal("/", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "Level1-Dir2", "File5.cshtml"), file.PhysicalPath);
Assert.Equal(Path.Combine("Level1-Dir2", "File5.cshtml"), file.RelativePhysicalPath);
});
}
[Fact]
public void EnumerateFiles_IteratesOverAllCshtmlUnderPath()
{
// Arrange
var fileProvider = new TestFileProvider("BasePath");
var directory1 = new TestDirectoryFileInfo
{
Name = "Level1-Dir1",
};
var file1 = fileProvider.AddFile("/File1.cshtml", "content");
var directory2 = new TestDirectoryFileInfo
{
Name = "Level1-Dir2",
};
fileProvider.AddDirectoryContent("/", new IFileInfo[] { directory1, file1, directory2 });
var file2 = fileProvider.AddFile("/Level1-Dir1/File2.cshtml", "content");
var file3 = fileProvider.AddFile("/Level1-Dir1/File3.cshtml", "content");
var file4 = fileProvider.AddFile("/Level1-Dir1/File4.txt", "content");
var directory3 = new TestDirectoryFileInfo
{
Name = "Level2-Dir1"
};
fileProvider.AddDirectoryContent("/Level1-Dir1", new IFileInfo[] { file2, directory3, file3, file4 });
var file5 = fileProvider.AddFile(Path.Combine("Level1-Dir2", "File5.cshtml"), "content");
fileProvider.AddDirectoryContent("/Level1-Dir2", new IFileInfo[] { file5 });
fileProvider.AddDirectoryContent("/Level1/Level2", new IFileInfo[0]);
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var razorFiles = fileSystem.EnumerateItems("/Level1-Dir1");
// Assert
Assert.Collection(razorFiles.OrderBy(f => f.FilePath),
file =>
{
Assert.Equal("/File2.cshtml", file.FilePath);
Assert.Equal("/Level1-Dir1", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "Level1-Dir1", "File2.cshtml"), file.PhysicalPath);
Assert.Equal(Path.Combine("Level1-Dir1", "File2.cshtml"), file.RelativePhysicalPath);
},
file =>
{
Assert.Equal("/File3.cshtml", file.FilePath);
Assert.Equal("/Level1-Dir1", file.BasePath);
Assert.Equal(Path.Combine("BasePath", "Level1-Dir1", "File3.cshtml"), file.PhysicalPath);
Assert.Equal(Path.Combine("Level1-Dir1", "File3.cshtml"), file.RelativePhysicalPath);
});
}
[Fact]
public void GetItem_ReturnsFileFromDisk()
{
var fileProvider = new TestFileProvider("BasePath");
var file1 = fileProvider.AddFile("/File1.cshtml", "content");
var file2 = fileProvider.AddFile("/File2.js", "content");
var file3 = fileProvider.AddFile("/File3.cshtml", "content");
fileProvider.AddDirectoryContent("/", new IFileInfo[] { file1, file2, file3 });
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var item = fileSystem.GetItem("/File3.cshtml", fileKind: null);
// Assert
Assert.True(item.Exists);
Assert.Equal("/File3.cshtml", item.FilePath);
Assert.Equal(string.Empty, item.BasePath);
Assert.Equal(Path.Combine("BasePath", "File3.cshtml"), item.PhysicalPath);
Assert.Equal("File3.cshtml", item.RelativePhysicalPath);
}
[Fact]
public void GetItem_PhysicalPathDoesNotStartWithContentRoot_ReturnsNull()
{
var fileProvider = new TestFileProvider("BasePath2");
var file1 = fileProvider.AddFile("/File1.cshtml", "content");
var file2 = fileProvider.AddFile("/File2.js", "content");
var file3 = fileProvider.AddFile("/File3.cshtml", "content");
fileProvider.AddDirectoryContent("/", new IFileInfo[] { file1, file2, file3 });
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var item = fileSystem.GetItem("/File3.cshtml", fileKind: null);
// Assert
Assert.True(item.Exists);
Assert.Equal("/File3.cshtml", item.FilePath);
Assert.Equal(string.Empty, item.BasePath);
Assert.Equal(Path.Combine("BasePath2", "File3.cshtml"), item.PhysicalPath);
Assert.Null(item.RelativePhysicalPath);
}
[Fact]
public void GetItem_ReturnsNotFoundResult()
{
// Arrange
var fileProvider = new TestFileProvider("BasePath");
var file = fileProvider.AddFile("/SomeFile.cshtml", "content");
fileProvider.AddDirectoryContent("/", new IFileInfo[] { file });
var fileSystem = GetRazorProjectFileSystem(fileProvider);
// Act
var item = fileSystem.GetItem("/NotFound.cshtml", fileKind: null);
// Assert
Assert.False(item.Exists);
}
private static FileProviderRazorProjectFileSystem GetRazorProjectFileSystem(
TestFileProvider fileProvider,
string contentRootPath = "BasePath")
{
#pragma warning disable ASPDEPR003 // Type or member is obsolete
var options = Options.Create(new MvcRazorRuntimeCompilationOptions
{
FileProviders = { fileProvider }
});
#pragma warning restore ASPDEPR003 // Type or member is obsolete
var compilationFileProvider = new RuntimeCompilationFileProvider(options);
var fileSystem = new FileProviderRazorProjectFileSystem(
compilationFileProvider,
Mock.Of<IWebHostEnvironment>(e => e.ContentRootPath == contentRootPath));
return fileSystem;
}
}
| FileProviderRazorProjectFileSystemTest |
csharp | unoplatform__uno | src/Uno.Foundation/Metadata/RangeAttribute.cs | {
"start": 189,
"end": 572
} | public partial class ____ : Attribute
{
/// <summary>
/// Creates and initializes a new instance of the attribute with the specified minimum and maximum values.
/// </summary>
/// <param name="minValue">The minimum value allowed.</param>
/// <param name="maxValue">The maximum value allowed.</param>
public RangeAttribute(int minValue, int maxValue) : base()
{
}
}
| RangeAttribute |
csharp | graphql-dotnet__graphql-dotnet | src/GraphQL.Tests/Types/AutoRegisteringInterfaceGraphTypeTests.cs | {
"start": 34184,
"end": 34284
} | private interface ____ { }
[OutputName("TestWithCustomName")]
| TestInterface_WithCustomInputName |
csharp | OrchardCMS__OrchardCore | test/OrchardCore.Tests/Apis/Context/AuthenticationContext.cs | {
"start": 112,
"end": 2923
} | internal sealed class ____ : AuthorizationHandler<PermissionRequirement>
{
private readonly PermissionsContext _permissionsContext;
// Used for http based graphql tests, marries a permission context to a request
public PermissionContextAuthorizationHandler(IHttpContextAccessor httpContextAccessor, IDictionary<string, PermissionsContext> permissionsContexts)
{
_permissionsContext = new PermissionsContext();
if (httpContextAccessor.HttpContext == null)
{
return;
}
var requestContext = httpContextAccessor.HttpContext.Request;
if (requestContext?.Headers.ContainsKey("PermissionsContext") == true &&
permissionsContexts.TryGetValue(requestContext.Headers["PermissionsContext"], out var permissionsContext))
{
_permissionsContext = permissionsContext;
}
}
// Used for static graphql test; passes a permissionsContext directly
public PermissionContextAuthorizationHandler(PermissionsContext permissionsContext)
{
_permissionsContext = permissionsContext;
}
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, PermissionRequirement requirement)
{
var permissions = (_permissionsContext.AuthorizedPermissions ?? []).ToList();
if (!_permissionsContext.UsePermissionsContext)
{
context.Succeed(requirement);
}
else if (permissions.Contains(requirement.Permission))
{
context.Succeed(requirement);
}
else
{
var grantingNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
GetGrantingNamesInternal(requirement.Permission, grantingNames);
if (permissions.Any(p => grantingNames.Contains(p.Name)))
{
context.Succeed(requirement);
}
else
{
context.Fail();
}
}
return Task.CompletedTask;
}
private static void GetGrantingNamesInternal(Permission permission, HashSet<string> stack)
{
// The given name is tested
stack.Add(permission.Name);
// Iterate implied permissions to grant, it present
if (permission.ImpliedBy != null && permission.ImpliedBy.Any())
{
foreach (var impliedBy in permission.ImpliedBy)
{
// Avoid potential recursion
if (impliedBy == null || stack.Contains(impliedBy.Name))
{
continue;
}
// Otherwise accumulate the implied permission names recursively
GetGrantingNamesInternal(impliedBy, stack);
}
}
}
}
| PermissionContextAuthorizationHandler |
csharp | dotnet__BenchmarkDotNet | tests/BenchmarkDotNet.IntegrationTests/ExceptionHandlingTests.cs | {
"start": 4248,
"end": 4982
} | public class ____
{
[IterationCleanup] public void Cleanup() => throw new Exception(IterationCleanupExceptionMessage);
[Benchmark] public void Throw() => throw new Exception(BenchmarkExceptionMessage);
}
[Fact]
public void WhenOneBenchmarkThrowsTheRunnerDoesNotThrow()
=> CanExecute<OneIsThrowing>(fullValidation: false); // we don't validate here because the report is expected to miss some results
[Fact]
public void WhenAllBenchmarksThrowsTheRunnerDoesNotThrow()
=> CanExecute<AlwaysThrow>(fullValidation: false); // we don't validate here because the report is expected to have no results
| ThrowInBenchmarkAndInIterationCleanup |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.