public void CompileProgram_Padding_FillsROM()
{
byte padding = 255;
var rom = new Sharp_LR35902_Assembler.Assembler().CompileProgram(new string[0], null, padding);
ListEqual(IEnumerableExtensions.ListOf(padding, rom.Length), rom);
}
public static string StringValue(object o, string language)
{
var(isLiteral, repr) = TryRenderLiteral(o, language);
if (!isLiteral)
{
var hasDeclaredToString = o.GetType().GetMethods().Any(x =>
{
if (x.Name != "ToString")
{
return(false);
}
if (IEnumerableExtensions.Any(x.GetParameters()))
{
return(false);
}
if (x.DeclaringType == typeof(object))
{
return(false);
}
if (x.DeclaringType.InheritsFromOrImplements <EnumerableQuery>())
{
return(false);
}
return(true);
});
if (hasDeclaredToString)
{
return(o.ToString());
}
}
return(repr);
}
public Terminal GetTerminal(string ip)
{
Terminal result;
int num;
while (true)
{
DataTable dataTable = SqlHelper.ExecuteDataset(this.constr, CommandType.Text, "select * from Terminal where ip=@ip", new SqlParameter[]
{
new SqlParameter("ip", ip)
}).Tables[0];
Terminal terminal = IEnumerableExtensions.ToList <Terminal>(dataTable).FirstOrDefault <Terminal>();
result = terminal;
num = 9079;
int arg_5E_0 = num;
num = 9079;
switch ((arg_5E_0 == num) ? 1 : 0)
{
case 0:
case 2:
continue;
}
break;
}
num = 1;
if (num != 0)
{
}
num = 0;
if (num != 0)
{
}
num = 0;
return(result);
}
static void Postfix(OcPl __instance)
{
if (!Settings.isUseVRM(__instance))
{
return;
}
string playername = Settings.getPlayerName(__instance);
if (!Settings.ReadBool(playername, "UseEquipAdjustment", false))
{
return;
}
var plEquipCtrl = __instance.EquipCtrl;
var plCommon = __instance.PlCommon;
var plEquips = GetPlEquips(plEquipCtrl);
plEquips.RemoveWhere(plEquip => plEquip == null); // Destroyされていたら null チェックが True になる
if (originalParentTransform.ContainsKey(plEquipCtrl) == false && plEquips.Any())
{
originalParentTransform.Add(plEquipCtrl, IEnumerableExtensions.First(plEquips).transform.parent);
}
foreach (var plEquip in plEquips)
{
AdjustEquipPos(plEquip, playername);
}
AdjustQuiverPos(__instance, __instance.PlCommon);
}
public void WithoutIgnoredObjects_ListHasNoIgnorableObjects_ShouldReturnSameList()
{
// Arrange
var list = new List <AnnoObject>
{
new AnnoObject
{
Template = "Dummy"
},
new AnnoObject
{
Template = "AnotherDummy"
}
};
// Act
var result = IEnumerableExtensions.WithoutIgnoredObjects(list);
// Assert
Assert.Equal(list.Count(), result.Count());
Assert.All(result, x =>
{
Assert.Contains(x, list);
});
}
public void TestMaxBy__EnumerableNull()
{
Assert.Throws <ArgumentNullException>(delegate
{
IEnumerableExtensions.MaxBy <TestContainer, int>(null, x => x.value);
});
}
public void Batch_ReturnsGroupsOfN()
{
var numbers = Enumerable.Range(1, 100);
var groups = IEnumerableExtensions.Batch(numbers, 10);
Assert.IsTrue(groups.All(g => g.Count() == 10));
}
public DnsResourceDataNamingAuthorityPointer(ushort order, ushort preference, DataSegment flags, DataSegment services, DataSegment regularExpression, DnsDomainName replacement)
{
if (flags == null)
{
throw new ArgumentNullException("flags");
}
if (!DnsResourceDataNamingAuthorityPointer.IsLegalFlags(flags))
{
throw new ArgumentException(string.Format((IFormatProvider)CultureInfo.InvariantCulture, "Flags ({0}) contain a non [a-zA-Z0-9] character.", new object[1]
{
(object)Encoding.ASCII.GetString(flags.Buffer, flags.StartOffset, flags.Length)
}), "flags");
}
this.Order = order;
this.Preference = preference;
this.Flags = !Enumerable.All <byte>((IEnumerable <byte>)flags, (Func <byte, bool>)(flag =>
{
if ((int)flag >= 97)
{
return((int)flag > 122);
}
return(true);
})) || !IEnumerableExtensions.IsStrictOrdered <byte>((IEnumerable <byte>)flags) ? new DataSegment(Enumerable.ToArray <byte>((IEnumerable <byte>)Enumerable.OrderBy <byte, byte>(Enumerable.Distinct <byte>(Enumerable.Select <byte, byte>((IEnumerable <byte>)flags, (Func <byte, byte>)(flag =>
{
if ((int)flag < 97 || (int)flag > 122)
{
return(flag);
}
return((byte)((int)flag + 65 - 97));
}))), (Func <byte, byte>)(flag => flag)))) : flags;
this.Services = services;
this.RegularExpression = regularExpression;
this.Replacement = replacement;
}
public void CreateTreeProperly()
{
var first = new ClassWithRecursion();
first.Name = "First";
var second = new ClassWithRecursion();
second.Name = "Second";
first.Subclass = second;
var sourceTree = new ObjectTreeItem(first);
sourceTree.CreateTree();
Trace.WriteLine(sourceTree.ToFormattedString());
Assert.IsNull(sourceTree.Parent);
Assert.IsNotNull(sourceTree.Childs);
Assert.IsTrue(IEnumerableExtensions.Any(sourceTree.Childs));
Assert.AreEqual(2, sourceTree.Childs.Count);
Assert.AreEqual(first, sourceTree.Item);
Assert.IsTrue(sourceTree.Childs.Any(item => item.Item == second));
foreach (var objectTreeItem in sourceTree.Childs)
{
Assert.AreEqual(sourceTree, objectTreeItem.Parent);
}
}
public void WithoutIgnoredObjects_ListHasNoIgnorableObjects_ShouldReturnSameList()
{
// Arrange
var list = new List <LayoutObject>
{
new LayoutObject(
new AnnoObject
{
Template = "Dummy"
}, mockedCoordinateHelper, mockedBrushCache, mockedPenCache),
new LayoutObject(
new AnnoObject
{
Template = "AnotherDummy"
}, mockedCoordinateHelper, mockedBrushCache, mockedPenCache),
};
// Act
var result = IEnumerableExtensions.WithoutIgnoredObjects(list);
// Assert
Assert.Equal(list.Count(), result.Count());
Assert.All(result, x =>
{
Assert.Contains(x, list);
});
}
public void WithoutIgnoredObjects_ListHasIgnorableObjects_ShouldReturnFilteredList()
{
// Arrange
var list = new List <LayoutObject>
{
new LayoutObject(
new AnnoObject
{
Template = "Blocker"
}, mockedCoordinateHelper, mockedBrushCache, mockedPenCache),
new LayoutObject(
new AnnoObject
{
Template = "Dummy"
}, mockedCoordinateHelper, mockedBrushCache, mockedPenCache),
new LayoutObject(
new AnnoObject
{
Template = "AnotherDummy"
}, mockedCoordinateHelper, mockedBrushCache, mockedPenCache),
};
// Act
var result = IEnumerableExtensions.WithoutIgnoredObjects(list);
// Assert
Assert.NotEqual(list.Count(), result.Count());
Assert.All(result, x =>
{
Assert.NotEqual("Blocker", x.WrappedAnnoObject.Template, StringComparer.OrdinalIgnoreCase);
});
}
public HttpParser FieldValue(out IEnumerable <byte> fieldValue)
{
if (!this.Success)
{
fieldValue = (IEnumerable <byte>)null;
return(this);
}
this.SkipLws();
this.FieldContent(out fieldValue);
if (!Enumerable.Any <byte>(fieldValue))
{
return(this);
}
while (this.Success)
{
this.SkipLws();
IEnumerable <byte> fieldContent;
this.FieldContent(out fieldContent);
if (Enumerable.Any <byte>(fieldContent))
{
fieldValue = Enumerable.Concat <byte>(IEnumerableExtensions.Concat <byte>(fieldValue, (byte)32), fieldContent);
}
else
{
break;
}
}
return(this);
}
public void WithoutIgnoredObjects_ListHasIgnorableObjects_ShouldReturnFilteredList()
{
// Arrange
var list = new List <AnnoObject>
{
new AnnoObject
{
Template = "Blocker"
},
new AnnoObject
{
Template = "Dummy"
},
new AnnoObject
{
Template = "AnotherDummy"
}
};
// Act
var result = IEnumerableExtensions.WithoutIgnoredObjects(list);
// Assert
Assert.NotEqual(list.Count(), result.Count());
Assert.All(result, x =>
{
Assert.NotEqual("Blocker", x.Template, StringComparer.OrdinalIgnoreCase);
});
}
public void WithoutIgnoredObjects_ListIsEmpty_ShouldReturnEmptyList()
{
// Arrange/Act
var result = IEnumerableExtensions.WithoutIgnoredObjects(new List <LayoutObject>());
// Assert
Assert.Empty(result);
}
public void WithoutIgnoredObjects_ListIsNull_ShouldReturnNull()
{
// Arrange/Act
var result = IEnumerableExtensions.WithoutIgnoredObjects(null);
// Assert
Assert.Null(result);
}
/// <summary>
/// Sets the property value
/// </summary>
/// <param name="propertyName">Property name</param>
/// <param name="value">Value</param>
public void SetPropertyValue(string propertyName, dynamic value)
{
IEnumerableExtensions.SetValue(valueDict, propertyName, value);
if (loadedIdentityValue && EntityManager.IsPrimaryKey(entityType, propertyName))
{
loadedIdentityValue = false;
}
}
public override string ToString()
{
if (this._utf8 == null)
{
this._utf8 = IEnumerableExtensions.SequenceToString <string>(Enumerable.Select <DataSegment, string>((IEnumerable <DataSegment>) this._labels, (Func <DataSegment, string>)(label => label.Decode(Encoding.UTF8))), '.') + ".";
}
return(this._utf8);
}
/// <summary>
/// Filters the entity types that this convention applies to based on a
/// predicate.
/// </summary>
/// <param name="predicate"> A function to test each entity type for a condition. </param>
/// <returns>
/// An <see cref="TypeConventionConfiguration{T}" /> instance so that multiple calls can be chained.
/// </returns>
public TypeConventionConfiguration <T> Where(Func <Type, bool> predicate)
{
Check.NotNull(predicate, "predicate");
return(new TypeConventionConfiguration <T>(
_conventionsConfiguration,
IEnumerableExtensions.Append(_predicates, predicate)));
}
public void Empty_IEnumerable_Returns_Zero()
{
var events = new List <Event>();
var version = IEnumerableExtensions.Version(events);
Assert.AreEqual(0, version);
}
public void EmptyIfNull_ReturnsOriginalEnumerationIfNotNull()
{
var ints = Enumerable.Range(1, 100);
var result = IEnumerableExtensions.EmptyIfNull(ints);
Assert.IsNotNull(result);
Assert.AreEqual(result, ints);
}
private static IList <T> EndOptions(IList <T> options, T end)
{
if (options.Count == 0 || (Enumerable.Last <T>((IEnumerable <T>)options).Equivalent((Option)end) || Options <T> .SumBytesLength((IEnumerable <T>)options) % 4 == 0))
{
return(options);
}
return((IList <T>) new List <T>(IEnumerableExtensions.Concat <T>((IEnumerable <T>)options, end)));
}
public void EmptyIfNull_ReturnsEmptyEnumerationIfNull()
{
var nullInts = (IEnumerable <int>)null;
var result = IEnumerableExtensions.EmptyIfNull(nullInts);
Assert.IsNotNull(result);
Assert.IsTrue(result.Count() == 0);
}
/// <summary>
/// Deletes the items from the database.
/// </summary>
/// <param name="serviceProvider">The application service provider.</param>
/// <param name="token">The cancellation token for the task.</param>
public async Task DeleteAsync(IServiceProvider serviceProvider, CancellationToken token)
{
// Check if there weren't any valid items found.
if (Items == null)
{
// Throw an exception.
throw new TaskException("No valid items could be found with the provided data.");
}
// Get the total number of batches.
var count = Math.Ceiling((double)Items.Count() / ApplicationDbContext.BatchSize);
// Go over each batch.
for (var index = 0; index < count; index++)
{
// Check if the cancellation was requested.
if (token.IsCancellationRequested)
{
// Break.
break;
}
// Get the items in the current batch.
var batchItems = Items
.Skip(index * ApplicationDbContext.BatchSize)
.Take(ApplicationDbContext.BatchSize);
// Get the IDs of the items in the current batch.
var batchIds = batchItems.Select(item => item.Id);
// Define the list of items to get.
var paths = new List <Path>();
// Use a new scope.
using (var scope = serviceProvider.CreateScope())
{
// Use a new context instance.
using var context = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>();
// Get the items with the provided IDs.
var items = context.Paths
.Where(item => batchIds.Contains(item.Id));
// Check if there were no items found.
if (items == null || !items.Any())
{
// Continue.
continue;
}
// Get the items found.
paths = items
.ToList();
}
// Get the IDs of the items.
var pathIds = paths
.Select(item => item.Id);
// Delete the related entities.
await PathExtensions.DeleteRelatedEntitiesAsync <PathNode>(pathIds, serviceProvider, token);
await PathExtensions.DeleteRelatedEntitiesAsync <PathEdge>(pathIds, serviceProvider, token);
// Delete the items.
await IEnumerableExtensions.DeleteAsync(paths, serviceProvider, token);
}
}
public void IsNullOrEmpty_Given_Predicate_When_Null_Returns_True()
{
IEnumerableExtensions // Arrange
.IsNullOrEmpty <string>( // Act
source: null,
predicate: e => true
)
.ShouldBeTrue(); // Assert
}
public void DistinctBy_throws_ArgumentNullException()
{
IEnumerable <object> enumeration = new[] { "a", "b", "c" };
object action(object value) => value;
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.DistinctBy((IEnumerable <object>)null, action).Iterate());
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.DistinctBy(enumeration, (Func <object, object>)null).Iterate());
}
public void SequenceEqual_equalitycomparer_throws_ArgumentNullException()
{
IEnumerable enumeration = new[] { "a", "b", "c" };
var comparer = new StringComparer();
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual(null, enumeration, comparer));
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual(enumeration, null, comparer));
IEnumerableExtensions.SequenceEqual(enumeration, enumeration, (IEqualityComparer)null);
}
public void SequenceEqual_generic_action_throws_ArgumentNullException()
{
IEnumerable <string> enumeration = new[] { "a", "b", "c" };
bool comparer(string f, string s) => f == s;
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual <string, string>((IEnumerable <string>)null, enumeration, comparer));
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual <string, string>(enumeration, (IEnumerable <string>)null, comparer));
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual <string, string>(enumeration, enumeration, (Func <string, string, bool>)null));
}
public void SequenceEqual_action_throws_ArgumentNullException()
{
IEnumerable enumeration = new[] { "a", "b", "c" };
bool comparer(object f, object s) => (string)f == (string)s;
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual(null, enumeration, comparer));
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual(enumeration, null, comparer));
Assert.Throws <ArgumentNullException>(() => IEnumerableExtensions.SequenceEqual(enumeration, enumeration, (Func <object, object, bool>)null));
}
public void ConvertToReadonly()
{
IEnumerable <Color> myList = new List <Color>()
{
Color.Blue, Color.White
};
IReadOnlyCollection <Color> myReadOnly = IEnumerableExtensions.ToReadOnlyCollection(myList);
Assert.AreEqual(((List <Color>)myList).Count, myReadOnly.Count);
}
/// <summary>
/// Filters the entity types that this convention applies to based on a
/// predicate.
/// </summary>
/// <param name="predicate"> A function to test each entity type for a condition. </param>
/// <returns>
/// An <see cref="TypeConventionConfiguration" /> instance so that multiple calls can be chained.
/// </returns>
public TypeConventionConfiguration Where(Func <Type, bool> predicate)
{
Check.NotNull(predicate, "predicate");
#if NETSTANDARD
return(new TypeConventionConfiguration(_conventionsConfiguration, IEnumerableExtensions.Append(_predicates, predicate)));
#else
return(new TypeConventionConfiguration(_conventionsConfiguration, _predicates.Append(predicate)));
#endif
}
